nestjs-ddd-cli 2.2.1 → 3.2.1

package/dist/commands/recipes/websocket.recipe.js

@@ -0,0 +1,453 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyWebSocketRecipe = applyWebSocketRecipe;
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const file_utils_1 = require("../../utils/file.utils");
+async function applyWebSocketRecipe(basePath) {
+    const sharedPath = path.join(basePath, 'src/shared');
+    const wsPath = path.join(sharedPath, 'websocket');
+    await (0, file_utils_1.ensureDir)(wsPath);
+    await (0, file_utils_1.ensureDir)(path.join(wsPath, 'gateways'));
+    await (0, file_utils_1.ensureDir)(path.join(wsPath, 'decorators'));
+    await (0, file_utils_1.ensureDir)(path.join(wsPath, 'guards'));
+    // Base Gateway
+    const baseGatewayContent = `import {
+  WebSocketGateway,
+  WebSocketServer,
+  OnGatewayInit,
+  OnGatewayConnection,
+  OnGatewayDisconnect,
+  SubscribeMessage,
+  MessageBody,
+  ConnectedSocket,
+} from "@nestjs/websockets";
+import { Logger } from "@nestjs/common";
+import { Server, Socket } from "socket.io";
+
+export interface WsClient extends Socket {
+  userId?: string;
+  tenantId?: string;
+  rooms: Set<string>;
+}
+
+@WebSocketGateway({
+  cors: {
+    origin: process.env.CORS_ORIGIN || "*",
+    credentials: true,
+  },
+  namespace: "/",
+  transports: ["websocket", "polling"],
+})
+export class BaseGateway
+  implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect
+{
+  @WebSocketServer()
+  server: Server;
+
+  protected readonly logger = new Logger(BaseGateway.name);
+  protected clients: Map<string, WsClient> = new Map();
+  protected userSockets: Map<string, Set<string>> = new Map();
+
+  afterInit(server: Server) {
+    this.logger.log("WebSocket Gateway initialized");
+  }
+
+  handleConnection(client: WsClient) {
+    this.logger.log(\`Client connected: \${client.id}\`);
+    this.clients.set(client.id, client);
+  }
+
+  handleDisconnect(client: WsClient) {
+    this.logger.log(\`Client disconnected: \${client.id}\`);
+    this.clients.delete(client.id);
+
+    // Remove from user sockets mapping
+    if (client.userId) {
+      const userSockets = this.userSockets.get(client.userId);
+      if (userSockets) {
+        userSockets.delete(client.id);
+        if (userSockets.size === 0) {
+          this.userSockets.delete(client.userId);
+        }
+      }
+    }
+  }
+
+  /**
+   * Associate a socket with a user ID
+   */
+  protected associateUser(client: WsClient, userId: string) {
+    client.userId = userId;
+
+    if (!this.userSockets.has(userId)) {
+      this.userSockets.set(userId, new Set());
+    }
+    this.userSockets.get(userId)!.add(client.id);
+  }
+
+  /**
+   * Send event to specific user (all their connected sockets)
+   */
+  protected sendToUser(userId: string, event: string, data: any) {
+    const sockets = this.userSockets.get(userId);
+    if (sockets) {
+      for (const socketId of sockets) {
+        this.server.to(socketId).emit(event, data);
+      }
+    }
+  }
+
+  /**
+   * Send event to all users in a room
+   */
+  protected sendToRoom(room: string, event: string, data: any) {
+    this.server.to(room).emit(event, data);
+  }
+
+  /**
+   * Broadcast to all connected clients
+   */
+  protected broadcast(event: string, data: any, excludeClient?: string) {
+    if (excludeClient) {
+      this.server.except(excludeClient).emit(event, data);
+    } else {
+      this.server.emit(event, data);
+    }
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(wsPath, 'gateways/base.gateway.ts'), baseGatewayContent);
+    // Events Gateway
+    const eventsGatewayContent = `import {
+  SubscribeMessage,
+  MessageBody,
+  ConnectedSocket,
+} from "@nestjs/websockets";
+import { UseGuards } from "@nestjs/common";
+import { BaseGateway, WsClient } from "./base.gateway";
+import { WsJwtGuard } from "../guards/ws-jwt.guard";
+
+export class EventsGateway extends BaseGateway {
+  @UseGuards(WsJwtGuard)
+  @SubscribeMessage("authenticate")
+  handleAuthenticate(
+    @ConnectedSocket() client: WsClient,
+    @MessageBody() data: { userId: string }
+  ) {
+    this.associateUser(client, data.userId);
+    return { event: "authenticated", data: { success: true } };
+  }
+
+  @SubscribeMessage("join_room")
+  handleJoinRoom(
+    @ConnectedSocket() client: WsClient,
+    @MessageBody() data: { room: string }
+  ) {
+    client.join(data.room);
+    client.rooms.add(data.room);
+    this.logger.log(\`Client \${client.id} joined room \${data.room}\`);
+
+    // Notify others in room
+    client.to(data.room).emit("user_joined", {
+      userId: client.userId,
+      room: data.room,
+    });
+
+    return { event: "joined_room", data: { room: data.room } };
+  }
+
+  @SubscribeMessage("leave_room")
+  handleLeaveRoom(
+    @ConnectedSocket() client: WsClient,
+    @MessageBody() data: { room: string }
+  ) {
+    client.leave(data.room);
+    client.rooms.delete(data.room);
+
+    // Notify others in room
+    client.to(data.room).emit("user_left", {
+      userId: client.userId,
+      room: data.room,
+    });
+
+    return { event: "left_room", data: { room: data.room } };
+  }
+
+  @SubscribeMessage("message")
+  handleMessage(
+    @ConnectedSocket() client: WsClient,
+    @MessageBody() data: { room?: string; content: string; type?: string }
+  ) {
+    const message = {
+      id: Date.now().toString(),
+      userId: client.userId,
+      content: data.content,
+      type: data.type || "text",
+      timestamp: new Date().toISOString(),
+    };
+
+    if (data.room) {
+      this.sendToRoom(data.room, "new_message", message);
+    } else {
+      this.broadcast("new_message", message, client.id);
+    }
+
+    return { event: "message_sent", data: message };
+  }
+
+  @SubscribeMessage("typing")
+  handleTyping(
+    @ConnectedSocket() client: WsClient,
+    @MessageBody() data: { room: string; isTyping: boolean }
+  ) {
+    client.to(data.room).emit("user_typing", {
+      userId: client.userId,
+      isTyping: data.isTyping,
+    });
+  }
+
+  @SubscribeMessage("ping")
+  handlePing(@ConnectedSocket() client: WsClient) {
+    return { event: "pong", data: { timestamp: Date.now() } };
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(wsPath, 'gateways/events.gateway.ts'), eventsGatewayContent);
+    // Presence service
+    const presenceServiceContent = `import { Injectable, Logger } from "@nestjs/common";
+import { Server } from "socket.io";
+
+export interface UserPresence {
+  userId: string;
+  status: "online" | "away" | "busy" | "offline";
+  lastSeen: Date;
+  metadata?: Record<string, any>;
+}
+
+@Injectable()
+export class PresenceService {
+  private readonly logger = new Logger(PresenceService.name);
+  private presence: Map<string, UserPresence> = new Map();
+  private server: Server;
+
+  setServer(server: Server) {
+    this.server = server;
+  }
+
+  /**
+   * Set user as online
+   */
+  setOnline(userId: string, metadata?: Record<string, any>) {
+    const presence: UserPresence = {
+      userId,
+      status: "online",
+      lastSeen: new Date(),
+      metadata,
+    };
+    this.presence.set(userId, presence);
+    this.broadcastPresence(userId, presence);
+  }
+
+  /**
+   * Set user as offline
+   */
+  setOffline(userId: string) {
+    const presence = this.presence.get(userId);
+    if (presence) {
+      presence.status = "offline";
+      presence.lastSeen = new Date();
+      this.broadcastPresence(userId, presence);
+    }
+  }
+
+  /**
+   * Update user status
+   */
+  updateStatus(userId: string, status: UserPresence["status"]) {
+    const presence = this.presence.get(userId);
+    if (presence) {
+      presence.status = status;
+      presence.lastSeen = new Date();
+      this.broadcastPresence(userId, presence);
+    }
+  }
+
+  /**
+   * Get user presence
+   */
+  getPresence(userId: string): UserPresence | undefined {
+    return this.presence.get(userId);
+  }
+
+  /**
+   * Get all online users
+   */
+  getOnlineUsers(): UserPresence[] {
+    return Array.from(this.presence.values()).filter(
+      (p) => p.status !== "offline"
+    );
+  }
+
+  /**
+   * Check if user is online
+   */
+  isOnline(userId: string): boolean {
+    const presence = this.presence.get(userId);
+    return presence?.status === "online";
+  }
+
+  /**
+   * Get presence for multiple users
+   */
+  getMultiplePresence(userIds: string[]): Map<string, UserPresence> {
+    const result = new Map<string, UserPresence>();
+    for (const id of userIds) {
+      const presence = this.presence.get(id);
+      if (presence) {
+        result.set(id, presence);
+      }
+    }
+    return result;
+  }
+
+  private broadcastPresence(userId: string, presence: UserPresence) {
+    if (this.server) {
+      this.server.emit("presence_update", { userId, presence });
+    }
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(wsPath, 'presence.service.ts'), presenceServiceContent);
+    // WS JWT Guard
+    const wsJwtGuardContent = `import { CanActivate, ExecutionContext, Injectable } from "@nestjs/common";
+import { JwtService } from "@nestjs/jwt";
+import { WsException } from "@nestjs/websockets";
+import { Socket } from "socket.io";
+
+@Injectable()
+export class WsJwtGuard implements CanActivate {
+  constructor(private jwtService: JwtService) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    try {
+      const client: Socket = context.switchToWs().getClient();
+      const token = this.extractToken(client);
+
+      if (!token) {
+        throw new WsException("Unauthorized: No token provided");
+      }
+
+      const payload = await this.jwtService.verifyAsync(token, {
+        secret: process.env.JWT_SECRET,
+      });
+
+      (client as any).userId = payload.sub;
+      (client as any).user = payload;
+
+      return true;
+    } catch (error) {
+      throw new WsException("Unauthorized: Invalid token");
+    }
+  }
+
+  private extractToken(client: Socket): string | undefined {
+    // Try auth header
+    const authHeader = client.handshake.headers.authorization;
+    if (authHeader?.startsWith("Bearer ")) {
+      return authHeader.slice(7);
+    }
+
+    // Try query param
+    const queryToken = client.handshake.query.token;
+    if (queryToken) {
+      return Array.isArray(queryToken) ? queryToken[0] : queryToken;
+    }
+
+    // Try auth object
+    const authToken = (client.handshake.auth as any)?.token;
+    if (authToken) {
+      return authToken;
+    }
+
+    return undefined;
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(wsPath, 'guards/ws-jwt.guard.ts'), wsJwtGuardContent);
+    // WebSocket module
+    const wsModuleContent = `import { Module, Global } from "@nestjs/common";
+import { JwtModule } from "@nestjs/jwt";
+import { EventsGateway } from "./gateways/events.gateway";
+import { PresenceService } from "./presence.service";
+import { WsJwtGuard } from "./guards/ws-jwt.guard";
+
+@Global()
+@Module({
+  imports: [
+    JwtModule.register({
+      secret: process.env.JWT_SECRET,
+      signOptions: { expiresIn: "7d" },
+    }),
+  ],
+  providers: [EventsGateway, PresenceService, WsJwtGuard],
+  exports: [EventsGateway, PresenceService],
+})
+export class WebSocketModule {}
+`;
+    await (0, file_utils_1.writeFile)(path.join(wsPath, 'websocket.module.ts'), wsModuleContent);
+    // Index exports
+    await (0, file_utils_1.writeFile)(path.join(wsPath, 'index.ts'), `export * from "./gateways/base.gateway";
+export * from "./gateways/events.gateway";
+export * from "./presence.service";
+export * from "./guards/ws-jwt.guard";
+export * from "./websocket.module";
+`);
+    await (0, file_utils_1.writeFile)(path.join(wsPath, 'gateways/index.ts'), `export * from "./base.gateway";
+export * from "./events.gateway";
+`);
+    await (0, file_utils_1.writeFile)(path.join(wsPath, 'guards/index.ts'), `export * from "./ws-jwt.guard";
+`);
+    console.log(chalk_1.default.green('  ✓ Base WebSocket Gateway with room management'));
+    console.log(chalk_1.default.green('  ✓ Events Gateway (join/leave rooms, messaging, typing)'));
+    console.log(chalk_1.default.green('  ✓ Presence Service (online/offline tracking)'));
+    console.log(chalk_1.default.green('  ✓ WebSocket JWT Guard'));
+    console.log(chalk_1.default.green('  ✓ WebSocket Module'));
+}
+//# sourceMappingURL=websocket.recipe.js.map

package/dist/commands/recipes/websocket.recipe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.recipe.js","sourceRoot":"","sources":["../../../src/commands/recipes/websocket.recipe.ts"],"names":[],"mappings":"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"}

package/dist/commands/resilience-patterns.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Circuit Breaker & Resilience Patterns Generator
+ * Implements retry logic, timeout handling, and fallback strategies
+ */
+export interface ResilienceOptions {
+    path?: string;
+    includeCircuitBreaker?: boolean;
+    includeRetry?: boolean;
+    includeTimeout?: boolean;
+    includeFallback?: boolean;
+    includeBulkhead?: boolean;
+}
+export declare function setupResiliencePatterns(basePath: string, options?: ResilienceOptions): Promise<void>;