spoonfeeder 0.1.0

package/templates/recipes/cloud-azure/cache/src/infrastructure/azure/redis.service.ts

@@ -0,0 +1,41 @@
+import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import Redis from 'ioredis';
+
+@Injectable()
+export class RedisService implements OnModuleDestroy {
+  private readonly logger = new Logger(RedisService.name);
+  private readonly client: Redis;
+
+  constructor(private readonly config: ConfigService) {
+    this.client = new Redis({
+      host: this.config.getOrThrow<string>('AZURE_REDIS_HOST'),
+      port: this.config.get<number>('AZURE_REDIS_PORT', 6380),
+      password: this.config.getOrThrow<string>('AZURE_REDIS_PASSWORD'),
+      tls: { servername: this.config.getOrThrow<string>('AZURE_REDIS_HOST') },
+    });
+
+    this.client.on('connect', () => this.logger.log('Connected to Azure Cache for Redis'));
+    this.client.on('error', (err) => this.logger.error('Redis connection error', err.stack));
+  }
+
+  async get(key: string): Promise<string | null> {
+    return this.client.get(key);
+  }
+
+  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);
+    }
+  }
+
+  async del(key: string): Promise<void> {
+    await this.client.del(key);
+  }
+
+  async onModuleDestroy(): Promise<void> {
+    await this.client.quit();
+  }
+}

package/templates/recipes/cloud-azure/cosmos-db/README.md

@@ -0,0 +1,57 @@
+# Azure Cosmos DB
+
+Azure Cosmos DB NoSQL database integration for NestJS.
+
+## Documentation
+
+- [Azure Cosmos DB Documentation](https://learn.microsoft.com/en-us/azure/cosmos-db/)
+- [@azure/cosmos on npm](https://www.npmjs.com/package/@azure/cosmos)
+- [@azure/identity on npm](https://www.npmjs.com/package/@azure/identity)
+
+## Dependencies
+
+| Package           | Version | Purpose                           |
+| ----------------- | ------- | --------------------------------- |
+| `@azure/cosmos`   | `4.2.0` | Azure Cosmos DB client            |
+| `@azure/identity` | `4.5.0` | Azure identity and authentication |
+
+## Environment Variables
+
+| Variable          | Default | Description                |
+| ----------------- | ------- | -------------------------- |
+| `COSMOS_ENDPOINT` | —       | Cosmos DB account endpoint |
+| `COSMOS_KEY`      | —       | Cosmos DB account key      |
+| `COSMOS_DATABASE` | `app`   | Cosmos DB database name    |
+
+## Usage
+
+```typescript
+import { CosmosDbService } from '@/azure/cosmos-db.service';
+
+@Injectable()
+export class UserRepository {
+  constructor(private readonly cosmos: CosmosDbService) {}
+
+  async findById(userId: string): Promise<User | undefined> {
+    return this.cosmos.readItem<User>(
+      this.configService.get('COSMOS_DATABASE'),
+      'users',
+      userId,
+      userId,
+    );
+  }
+
+  async save(user: User): Promise<void> {
+    await this.cosmos.upsertItem(this.configService.get('COSMOS_DATABASE'), 'users', user);
+  }
+
+  async findByEmail(email: string): Promise<User[]> {
+    return this.cosmos.queryItems<User>(
+      this.configService.get('COSMOS_DATABASE'),
+      'users',
+      'SELECT * FROM c WHERE c.email = @email',
+      [{ name: '@email', value: email }],
+    );
+  }
+}
+```

package/templates/recipes/cloud-azure/cosmos-db/src/infrastructure/azure/cosmos-db.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+
+import { CosmosDbService } from './cosmos-db.service';
+
+@Module({
+  imports: [ConfigModule],
+  providers: [CosmosDbService],
+  exports: [CosmosDbService],
+})
+export class CosmosDbModule {}

package/templates/recipes/cloud-azure/cosmos-db/src/infrastructure/azure/cosmos-db.service.ts

@@ -0,0 +1,55 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { CosmosClient, Container, ItemDefinition, SqlQuerySpec, FeedResponse } from '@azure/cosmos';
+
+@Injectable()
+export class CosmosDbService {
+  private readonly logger = new Logger(CosmosDbService.name);
+  private readonly client: CosmosClient;
+  private readonly databaseId: string;
+
+  constructor(private readonly config: ConfigService) {
+    const endpoint = this.config.getOrThrow<string>('AZURE_COSMOS_ENDPOINT');
+    const key = this.config.getOrThrow<string>('AZURE_COSMOS_KEY');
+    this.databaseId = this.config.getOrThrow<string>('AZURE_COSMOS_DATABASE');
+    this.client = new CosmosClient({ endpoint, key });
+  }
+
+  async getItem<T extends ItemDefinition>(
+    containerId: string,
+    id: string,
+    partitionKey: string,
+  ): Promise<T> {
+    const container = this.getContainer(containerId);
+    const { resource } = await container.item(id, partitionKey).read<T>();
+    this.logger.log(`Retrieved item "${id}" from "${containerId}"`);
+    return resource as T;
+  }
+
+  async createItem<T extends ItemDefinition>(containerId: string, item: T): Promise<T> {
+    const container = this.getContainer(containerId);
+    const { resource } = await container.items.create<T>(item);
+    this.logger.log(`Created item in "${containerId}"`);
+    return resource as T;
+  }
+
+  async queryItems<T extends ItemDefinition>(
+    containerId: string,
+    query: SqlQuerySpec,
+  ): Promise<T[]> {
+    const container = this.getContainer(containerId);
+    const { resources }: FeedResponse<T> = await container.items.query<T>(query).fetchAll();
+    this.logger.log(`Query returned ${resources.length} item(s) from "${containerId}"`);
+    return resources;
+  }
+
+  async deleteItem(containerId: string, id: string, partitionKey: string): Promise<void> {
+    const container = this.getContainer(containerId);
+    await container.item(id, partitionKey).delete();
+    this.logger.log(`Deleted item "${id}" from "${containerId}"`);
+  }
+
+  private getContainer(containerId: string): Container {
+    return this.client.database(this.databaseId).container(containerId);
+  }
+}

package/templates/recipes/cloud-azure/entra-id/README.md

@@ -0,0 +1,42 @@
+# Azure Entra ID
+
+Azure Entra ID (formerly Azure AD) authentication for NestJS.
+
+## Documentation
+
+- [Azure Entra ID Documentation](https://learn.microsoft.com/en-us/entra/identity/)
+- [MSAL Node Documentation](https://learn.microsoft.com/en-us/entra/msal/node/)
+- [@azure/msal-node on npm](https://www.npmjs.com/package/@azure/msal-node)
+- [@azure/identity on npm](https://www.npmjs.com/package/@azure/identity)
+- [NestJS Authentication](https://docs.nestjs.com/security/authentication)
+
+## Dependencies
+
+| Package            | Version  | Purpose                           |
+| ------------------ | -------- | --------------------------------- |
+| `@azure/msal-node` | `2.16.2` | Microsoft Authentication Library  |
+| `@azure/identity`  | `4.5.0`  | Azure identity and authentication |
+
+## Environment Variables
+
+| Variable              | Default | Description                            |
+| --------------------- | ------- | -------------------------------------- |
+| `AZURE_TENANT_ID`     | —       | Azure Entra ID tenant ID               |
+| `AZURE_CLIENT_ID`     | —       | Azure Entra ID client (application) ID |
+| `AZURE_CLIENT_SECRET` | —       | Azure Entra ID client secret           |
+
+## Usage
+
+```typescript
+import { EntraIdGuard } from '@/azure/entra-id.guard';
+import { CurrentUser } from '@/auth/current-user.decorator';
+
+@Controller('orders')
+@UseGuards(EntraIdGuard)
+export class OrdersController {
+  @Get()
+  findAll(@CurrentUser() user: EntraIdUser) {
+    return this.ordersService.findByUser(user.oid);
+  }
+}
+```

package/templates/recipes/cloud-azure/entra-id/src/infrastructure/azure/entra-id.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+
+import { EntraIdService } from './entra-id.service';
+
+@Module({
+  imports: [ConfigModule],
+  providers: [EntraIdService],
+  exports: [EntraIdService],
+})
+export class EntraIdModule {}

package/templates/recipes/cloud-azure/entra-id/src/infrastructure/azure/entra-id.service.ts

@@ -0,0 +1,55 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import {
+  ConfidentialClientApplication,
+  AuthenticationResult,
+  Configuration,
+} from '@azure/msal-node';
+import * as jwt from 'jsonwebtoken';
+import * as jwksClient from 'jwks-rsa';
+
+@Injectable()
+export class EntraIdService {
+  private readonly logger = new Logger(EntraIdService.name);
+  private readonly msalClient: ConfidentialClientApplication;
+  private readonly tenantId: string;
+
+  constructor(private readonly config: ConfigService) {
+    this.tenantId = this.config.getOrThrow<string>('AZURE_TENANT_ID');
+
+    const msalConfig: Configuration = {
+      auth: {
+        clientId: this.config.getOrThrow<string>('AZURE_CLIENT_ID'),
+        clientSecret: this.config.getOrThrow<string>('AZURE_CLIENT_SECRET'),
+        authority: `https://login.microsoftonline.com/${this.tenantId}`,
+      },
+    };
+
+    this.msalClient = new ConfidentialClientApplication(msalConfig);
+  }
+
+  async acquireToken(scopes: string[]): Promise<AuthenticationResult | null> {
+    const result = await this.msalClient.acquireTokenByClientCredential({ scopes });
+    this.logger.log('Token acquired via client credentials');
+    return result;
+  }
+
+  async validateToken(token: string): Promise<jwt.JwtPayload> {
+    const jwks = jwksClient({
+      jwksUri: `https://login.microsoftonline.com/${this.tenantId}/discovery/v2.0/keys`,
+    });
+
+    const decoded = jwt.decode(token, { complete: true });
+    if (!decoded) {
+      throw new Error('Invalid token: unable to decode');
+    }
+
+    const key = await jwks.getSigningKey(decoded.header.kid);
+    const publicKey = key.getPublicKey();
+
+    return jwt.verify(token, publicKey, {
+      audience: this.config.getOrThrow<string>('AZURE_CLIENT_ID'),
+      issuer: `https://login.microsoftonline.com/${this.tenantId}/v2.0`,
+    }) as jwt.JwtPayload;
+  }
+}

package/templates/recipes/cloud-azure/front-door/README.md

@@ -0,0 +1,48 @@
+# Azure Front Door
+
+Azure Front Door CDN and global load balancer integration for NestJS.
+
+## Documentation
+
+- [Azure Front Door Documentation](https://learn.microsoft.com/en-us/azure/frontdoor/)
+- [Restrict access to Azure Front Door origins](https://learn.microsoft.com/en-us/azure/frontdoor/origin-security)
+
+## Dependencies
+
+No additional npm dependencies are required. Front Door validation uses built-in NestJS guards.
+
+## Environment Variables
+
+| Variable                   | Default        | Description                                |
+| -------------------------- | -------------- | ------------------------------------------ |
+| `AZURE_FRONTDOOR_HOSTNAME` | —              | Azure Front Door hostname                  |
+| `AZURE_FRONTDOOR_HEADER`   | `X-Azure-FDID` | Front Door ID header name                  |
+| `AZURE_FRONTDOOR_ID`       | —              | Azure Front Door ID for request validation |
+
+## Usage
+
+```typescript
+import { FrontDoorGuard } from '@/azure/front-door.guard';
+
+@Controller()
+@UseGuards(FrontDoorGuard)
+export class AppController {
+  @Get('health')
+  health() {
+    return { status: 'ok' };
+  }
+}
+
+// Guard implementation
+@Injectable()
+export class FrontDoorGuard implements CanActivate {
+  constructor(private readonly config: ConfigService) {}
+
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    const headerName = this.config.get('AZURE_FRONTDOOR_HEADER', 'X-Azure-FDID');
+    const expectedId = this.config.get('AZURE_FRONTDOOR_ID');
+    return request.headers[headerName.toLowerCase()] === expectedId;
+  }
+}
+```

package/templates/recipes/cloud-azure/functions/README.md

@@ -0,0 +1,48 @@
+# Azure Functions
+
+Azure Functions integration for serverless NestJS workloads.
+
+## Documentation
+
+- [Azure Functions Documentation](https://learn.microsoft.com/en-us/azure/azure-functions/)
+- [@azure/functions on npm](https://www.npmjs.com/package/@azure/functions)
+- [NestJS Serverless](https://docs.nestjs.com/faq/serverless)
+
+## Dependencies
+
+| Package            | Version | Purpose                 |
+| ------------------ | ------- | ----------------------- |
+| `@azure/functions` | `4.6.0` | Azure Functions runtime |
+
+## Environment Variables
+
+| Variable                      | Default       | Description                 |
+| ----------------------------- | ------------- | --------------------------- |
+| `AZURE_FUNCTIONS_ENVIRONMENT` | `Development` | Azure Functions environment |
+
+## Usage
+
+```typescript
+import { app } from '@azure/functions';
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+let cachedApp: INestApplication;
+
+async function getApp(): Promise<INestApplication> {
+  if (!cachedApp) {
+    cachedApp = await NestFactory.create(AppModule);
+    await cachedApp.init();
+  }
+  return cachedApp;
+}
+
+app.http('handler', {
+  methods: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
+  route: '{*path}',
+  handler: async (request, context) => {
+    const nestApp = await getApp();
+    return nestApp.getHttpAdapter().getInstance()(request, context);
+  },
+});
+```

package/templates/recipes/cloud-azure/key-vault/README.md

@@ -0,0 +1,42 @@
+# Azure Key Vault
+
+Azure Key Vault for secret and key management in NestJS.
+
+## Documentation
+
+- [Azure Key Vault Documentation](https://learn.microsoft.com/en-us/azure/key-vault/)
+- [@azure/keyvault-secrets on npm](https://www.npmjs.com/package/@azure/keyvault-secrets)
+- [@azure/identity on npm](https://www.npmjs.com/package/@azure/identity)
+- [NestJS Configuration](https://docs.nestjs.com/techniques/configuration)
+
+## Dependencies
+
+| Package                   | Version | Purpose                           |
+| ------------------------- | ------- | --------------------------------- |
+| `@azure/keyvault-secrets` | `4.9.0` | Azure Key Vault secrets client    |
+| `@azure/identity`         | `4.5.0` | Azure identity and authentication |
+
+## Environment Variables
+
+| Variable             | Default | Description                                      |
+| -------------------- | ------- | ------------------------------------------------ |
+| `AZURE_KEYVAULT_URL` | —       | Key Vault URL (https://\<name\>.vault.azure.net) |
+
+## Usage
+
+```typescript
+import { KeyVaultService } from '@/azure/key-vault.service';
+
+@Injectable()
+export class DatabaseConfig {
+  constructor(private readonly keyVault: KeyVaultService) {}
+
+  async getDatabasePassword(): Promise<string> {
+    return this.keyVault.getSecret('database-password');
+  }
+
+  async getApiKey(name: string): Promise<string> {
+    return this.keyVault.getSecret(name);
+  }
+}
+```

package/templates/recipes/cloud-azure/key-vault/src/infrastructure/azure/key-vault.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+
+import { KeyVaultService } from './key-vault.service';
+
+@Module({
+  imports: [ConfigModule],
+  providers: [KeyVaultService],
+  exports: [KeyVaultService],
+})
+export class KeyVaultModule {}

package/templates/recipes/cloud-azure/key-vault/src/infrastructure/azure/key-vault.service.ts

@@ -0,0 +1,27 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { SecretClient } from '@azure/keyvault-secrets';
+import { DefaultAzureCredential } from '@azure/identity';
+
+@Injectable()
+export class KeyVaultService {
+  private readonly logger = new Logger(KeyVaultService.name);
+  private readonly client: SecretClient;
+
+  constructor(private readonly config: ConfigService) {
+    const vaultUrl = this.config.getOrThrow<string>('AZURE_KEY_VAULT_URL');
+    const credential = new DefaultAzureCredential();
+    this.client = new SecretClient(vaultUrl, credential);
+  }
+
+  async getSecret(name: string): Promise<string | undefined> {
+    const secret = await this.client.getSecret(name);
+    this.logger.log(`Retrieved secret "${name}"`);
+    return secret.value;
+  }
+
+  async setSecret(name: string, value: string): Promise<void> {
+    await this.client.setSecret(name, value);
+    this.logger.log(`Set secret "${name}"`);
+  }
+}

package/templates/recipes/cloud-azure/service-bus/README.md

@@ -0,0 +1,49 @@
+# Azure Service Bus
+
+Azure Service Bus for enterprise messaging in NestJS.
+
+## Documentation
+
+- [Azure Service Bus Documentation](https://learn.microsoft.com/en-us/azure/service-bus-messaging/)
+- [@azure/service-bus on npm](https://www.npmjs.com/package/@azure/service-bus)
+- [@azure/identity on npm](https://www.npmjs.com/package/@azure/identity)
+- [NestJS Microservices](https://docs.nestjs.com/microservices/basics)
+
+## Dependencies
+
+| Package              | Version | Purpose                           |
+| -------------------- | ------- | --------------------------------- |
+| `@azure/service-bus` | `7.9.5` | Azure Service Bus client          |
+| `@azure/identity`    | `4.5.0` | Azure identity and authentication |
+
+## Environment Variables
+
+| Variable                             | Default | Description                   |
+| ------------------------------------ | ------- | ----------------------------- |
+| `AZURE_SERVICEBUS_CONNECTION_STRING` | —       | Service Bus connection string |
+| `AZURE_SERVICEBUS_QUEUE`             | —       | Service Bus queue name        |
+
+## Usage
+
+```typescript
+import { ServiceBusService } from '@/azure/service-bus.service';
+
+@Injectable()
+export class OrderProcessor {
+  constructor(private readonly serviceBus: ServiceBusService) {}
+
+  async sendMessage(order: Order): Promise<void> {
+    await this.serviceBus.sendMessage(this.configService.get('AZURE_SERVICEBUS_QUEUE'), {
+      body: order,
+    });
+  }
+
+  async receiveMessages(): Promise<Order[]> {
+    const messages = await this.serviceBus.receiveMessages(
+      this.configService.get('AZURE_SERVICEBUS_QUEUE'),
+      { maxMessageCount: 10 },
+    );
+    return messages.map((m) => m.body as Order);
+  }
+}
+```

package/templates/recipes/cloud-azure/service-bus/src/infrastructure/azure/service-bus.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+
+import { ServiceBusService } from './service-bus.service';
+
+@Module({
+  imports: [ConfigModule],
+  providers: [ServiceBusService],
+  exports: [ServiceBusService],
+})
+export class ServiceBusModule {}

package/templates/recipes/cloud-azure/service-bus/src/infrastructure/azure/service-bus.service.ts

@@ -0,0 +1,52 @@
+import { Injectable, Logger, OnModuleDestroy } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import {
+  ServiceBusClient,
+  ServiceBusMessage,
+  ServiceBusReceivedMessage,
+  ServiceBusSender,
+  ServiceBusReceiver,
+} from '@azure/service-bus';
+
+@Injectable()
+export class ServiceBusService implements OnModuleDestroy {
+  private readonly logger = new Logger(ServiceBusService.name);
+  private readonly client: ServiceBusClient;
+
+  constructor(private readonly config: ConfigService) {
+    const connectionString = this.config.getOrThrow<string>('AZURE_SERVICE_BUS_CONNECTION_STRING');
+    this.client = new ServiceBusClient(connectionString);
+  }
+
+  async sendMessage(queueOrTopic: string, body: unknown): Promise<void> {
+    const sender: ServiceBusSender = this.client.createSender(queueOrTopic);
+
+    try {
+      const message: ServiceBusMessage = { body };
+      await sender.sendMessages(message);
+      this.logger.log(`Message sent to "${queueOrTopic}"`);
+    } finally {
+      await sender.close();
+    }
+  }
+
+  async receiveMessages(
+    queueOrTopic: string,
+    maxMessageCount = 10,
+    maxWaitTimeInMs = 5000,
+  ): Promise<ServiceBusReceivedMessage[]> {
+    const receiver: ServiceBusReceiver = this.client.createReceiver(queueOrTopic);
+
+    try {
+      const messages = await receiver.receiveMessages(maxMessageCount, { maxWaitTimeInMs });
+      this.logger.log(`Received ${messages.length} message(s) from "${queueOrTopic}"`);
+      return messages;
+    } finally {
+      await receiver.close();
+    }
+  }
+
+  async onModuleDestroy(): Promise<void> {
+    await this.client.close();
+  }
+}

package/templates/recipes/cloud-azure/sql-database/README.md

@@ -0,0 +1,54 @@
+# Azure SQL Database
+
+Azure SQL Database managed connection for NestJS.
+
+## Documentation
+
+- [Azure SQL Database Documentation](https://learn.microsoft.com/en-us/azure/azure-sql/database/)
+- [mssql on npm](https://www.npmjs.com/package/mssql)
+- [@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                |
+| `mssql`           | `11.0.1` | Microsoft SQL Server driver |
+
+## Environment Variables
+
+| Variable             | Default | Description               |
+| -------------------- | ------- | ------------------------- |
+| `AZURE_SQL_HOST`     | —       | Azure SQL server hostname |
+| `AZURE_SQL_PORT`     | `1433`  | Azure SQL port            |
+| `AZURE_SQL_DATABASE` | `app`   | Azure SQL database name   |
+| `AZURE_SQL_USERNAME` | —       | Azure SQL username        |
+| `AZURE_SQL_PASSWORD` | —       | Azure SQL password        |
+
+## Usage
+
+```typescript
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ConfigService } from '@nestjs/config';
+
+@Module({
+  imports: [
+    TypeOrmModule.forRootAsync({
+      inject: [ConfigService],
+      useFactory: (config: ConfigService) => ({
+        type: 'mssql',
+        host: config.getOrThrow('AZURE_SQL_HOST'),
+        port: config.get<number>('AZURE_SQL_PORT', 1433),
+        database: config.get('AZURE_SQL_DATABASE'),
+        username: config.get('AZURE_SQL_USERNAME'),
+        password: config.get('AZURE_SQL_PASSWORD'),
+        options: { encrypt: true, trustServerCertificate: false },
+        autoLoadEntities: true,
+      }),
+    }),
+  ],
+})
+export class DatabaseModule {}
+```

package/templates/recipes/cloud-gcp/README.md

@@ -0,0 +1,18 @@
+# GCP Cloud Recipes
+
+Google Cloud Platform integrations for NestJS applications.
+
+## Recipes
+
+| Recipe                                | Description                                          |
+| ------------------------------------- | ---------------------------------------------------- |
+| [Cloud CDN](./cloud-cdn/)             | Content delivery with signed URL support             |
+| [Cloud Functions](./cloud-functions/) | Serverless NestJS workloads                          |
+| [Cloud Logging](./cloud-logging/)     | Stackdriver logging integration                      |
+| [Cloud SQL](./cloud-sql/)             | Managed database connection                          |
+| [Cloud Storage](./cloud-storage/)     | Object storage for files                             |
+| [Firebase Auth](./firebase-auth/)     | User identity management with Firebase               |
+| [Firestore](./firestore/)             | NoSQL document database                              |
+| [Memorystore](./memorystore/)         | Managed Redis caching service                        |
+| [Pub/Sub](./pubsub/)                  | Messaging integration for event-driven architectures |
+| [Secret Manager](./secret-manager/)   | Secret storage and retrieval                         |