nestjs-ddd-cli 2.2.1 → 3.2.1

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

@@ -0,0 +1,472 @@
+"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.applyOAuth2Recipe = applyOAuth2Recipe;
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const file_utils_1 = require("../../utils/file.utils");
+async function applyOAuth2Recipe(basePath) {
+    const sharedPath = path.join(basePath, 'src/shared');
+    const oauthPath = path.join(sharedPath, 'oauth');
+    await (0, file_utils_1.ensureDir)(oauthPath);
+    await (0, file_utils_1.ensureDir)(path.join(oauthPath, 'strategies'));
+    await (0, file_utils_1.ensureDir)(path.join(oauthPath, 'guards'));
+    // OAuth types
+    const oauthTypesContent = `export interface OAuthProfile {
+  provider: string;
+  providerId: string;
+  email: string;
+  emailVerified: boolean;
+  firstName?: string;
+  lastName?: string;
+  displayName?: string;
+  avatarUrl?: string;
+  accessToken: string;
+  refreshToken?: string;
+  raw: any;
+}
+
+export interface OAuthUser {
+  id: string;
+  email: string;
+  providers: OAuthProvider[];
+}
+
+export interface OAuthProvider {
+  provider: string;
+  providerId: string;
+  accessToken?: string;
+  refreshToken?: string;
+  linkedAt: Date;
+}
+
+export type OAuthProviderType = "google" | "github" | "microsoft" | "facebook";
+`;
+    await (0, file_utils_1.writeFile)(path.join(oauthPath, 'oauth.types.ts'), oauthTypesContent);
+    // Google Strategy
+    const googleStrategyContent = `import { Injectable } from "@nestjs/common";
+import { PassportStrategy } from "@nestjs/passport";
+import { Strategy, VerifyCallback, Profile } from "passport-google-oauth20";
+import { OAuthProfile } from "../oauth.types";
+
+@Injectable()
+export class GoogleStrategy extends PassportStrategy(Strategy, "google") {
+  constructor() {
+    super({
+      clientID: process.env.GOOGLE_CLIENT_ID,
+      clientSecret: process.env.GOOGLE_CLIENT_SECRET,
+      callbackURL: process.env.GOOGLE_CALLBACK_URL || "/auth/google/callback",
+      scope: ["email", "profile"],
+    });
+  }
+
+  async validate(
+    accessToken: string,
+    refreshToken: string,
+    profile: Profile,
+    done: VerifyCallback
+  ): Promise<void> {
+    const { id, emails, name, photos, displayName } = profile;
+
+    const oauthProfile: OAuthProfile = {
+      provider: "google",
+      providerId: id,
+      email: emails?.[0]?.value || "",
+      emailVerified: emails?.[0]?.verified || false,
+      firstName: name?.givenName,
+      lastName: name?.familyName,
+      displayName: displayName,
+      avatarUrl: photos?.[0]?.value,
+      accessToken,
+      refreshToken,
+      raw: profile._json,
+    };
+
+    done(null, oauthProfile);
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(oauthPath, 'strategies/google.strategy.ts'), googleStrategyContent);
+    // GitHub Strategy
+    const githubStrategyContent = `import { Injectable } from "@nestjs/common";
+import { PassportStrategy } from "@nestjs/passport";
+import { Strategy, Profile } from "passport-github2";
+import { OAuthProfile } from "../oauth.types";
+
+@Injectable()
+export class GitHubStrategy extends PassportStrategy(Strategy, "github") {
+  constructor() {
+    super({
+      clientID: process.env.GITHUB_CLIENT_ID,
+      clientSecret: process.env.GITHUB_CLIENT_SECRET,
+      callbackURL: process.env.GITHUB_CALLBACK_URL || "/auth/github/callback",
+      scope: ["user:email"],
+    });
+  }
+
+  async validate(
+    accessToken: string,
+    refreshToken: string,
+    profile: Profile,
+    done: (err: any, user: any) => void
+  ): Promise<void> {
+    const { id, emails, displayName, photos, username } = profile;
+
+    const oauthProfile: OAuthProfile = {
+      provider: "github",
+      providerId: id,
+      email: emails?.[0]?.value || "",
+      emailVerified: true, // GitHub verifies emails
+      displayName: displayName || username,
+      avatarUrl: photos?.[0]?.value,
+      accessToken,
+      refreshToken,
+      raw: profile._json,
+    };
+
+    done(null, oauthProfile);
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(oauthPath, 'strategies/github.strategy.ts'), githubStrategyContent);
+    // OAuth Guards
+    const oauthGuardsContent = `import { Injectable, ExecutionContext } from "@nestjs/common";
+import { AuthGuard } from "@nestjs/passport";
+
+@Injectable()
+export class GoogleAuthGuard extends AuthGuard("google") {
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const result = (await super.canActivate(context)) as boolean;
+    const request = context.switchToHttp().getRequest();
+    await super.logIn(request);
+    return result;
+  }
+}
+
+@Injectable()
+export class GitHubAuthGuard extends AuthGuard("github") {
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const result = (await super.canActivate(context)) as boolean;
+    const request = context.switchToHttp().getRequest();
+    await super.logIn(request);
+    return result;
+  }
+}
+
+@Injectable()
+export class OAuthCallbackGuard extends AuthGuard(["google", "github"]) {
+  handleRequest(err: any, user: any, info: any) {
+    if (err || !user) {
+      throw err || new Error("OAuth authentication failed");
+    }
+    return user;
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(oauthPath, 'guards/oauth.guard.ts'), oauthGuardsContent);
+    // OAuth Service
+    const oauthServiceContent = `import { Injectable, Logger, UnauthorizedException } from "@nestjs/common";
+import { JwtService } from "@nestjs/jwt";
+import { OAuthProfile, OAuthUser, OAuthProvider } from "./oauth.types";
+
+@Injectable()
+export class OAuthService {
+  private readonly logger = new Logger(OAuthService.name);
+
+  constructor(private jwtService: JwtService) {}
+
+  /**
+   * Handle OAuth callback - find or create user
+   */
+  async handleOAuthLogin(profile: OAuthProfile): Promise<{
+    user: OAuthUser;
+    accessToken: string;
+    isNewUser: boolean;
+  }> {
+    // TODO: Implement actual user lookup/creation
+    // This is a placeholder implementation
+
+    const existingUser = await this.findUserByProvider(
+      profile.provider,
+      profile.providerId
+    );
+
+    if (existingUser) {
+      // Update tokens
+      await this.updateProviderTokens(
+        existingUser.id,
+        profile.provider,
+        profile.accessToken,
+        profile.refreshToken
+      );
+
+      const accessToken = await this.generateJwtToken(existingUser);
+      return { user: existingUser, accessToken, isNewUser: false };
+    }
+
+    // Check if user exists with same email
+    const userByEmail = await this.findUserByEmail(profile.email);
+
+    if (userByEmail) {
+      // Link new provider to existing account
+      await this.linkProvider(userByEmail.id, profile);
+      const accessToken = await this.generateJwtToken(userByEmail);
+      return { user: userByEmail, accessToken, isNewUser: false };
+    }
+
+    // Create new user
+    const newUser = await this.createUserFromOAuth(profile);
+    const accessToken = await this.generateJwtToken(newUser);
+    return { user: newUser, accessToken, isNewUser: true };
+  }
+
+  /**
+   * Link OAuth provider to existing account
+   */
+  async linkProvider(userId: string, profile: OAuthProfile): Promise<void> {
+    const provider: OAuthProvider = {
+      provider: profile.provider,
+      providerId: profile.providerId,
+      accessToken: profile.accessToken,
+      refreshToken: profile.refreshToken,
+      linkedAt: new Date(),
+    };
+
+    // TODO: Save provider to database
+    this.logger.log(\`Linked \${profile.provider} to user \${userId}\`);
+  }
+
+  /**
+   * Unlink OAuth provider from account
+   */
+  async unlinkProvider(userId: string, provider: string): Promise<void> {
+    // TODO: Remove provider from database
+    // Ensure user has at least one auth method remaining
+    this.logger.log(\`Unlinked \${provider} from user \${userId}\`);
+  }
+
+  /**
+   * Generate JWT token for user
+   */
+  async generateJwtToken(user: OAuthUser): Promise<string> {
+    const payload = {
+      sub: user.id,
+      email: user.email,
+    };
+
+    return this.jwtService.signAsync(payload);
+  }
+
+  /**
+   * Refresh OAuth access token
+   */
+  async refreshProviderToken(
+    userId: string,
+    provider: string
+  ): Promise<string | null> {
+    // TODO: Implement token refresh using provider's refresh token
+    return null;
+  }
+
+  // Placeholder methods - implement with your actual data layer
+  private async findUserByProvider(
+    provider: string,
+    providerId: string
+  ): Promise<OAuthUser | null> {
+    return null;
+  }
+
+  private async findUserByEmail(email: string): Promise<OAuthUser | null> {
+    return null;
+  }
+
+  private async createUserFromOAuth(profile: OAuthProfile): Promise<OAuthUser> {
+    return {
+      id: "new-user-id",
+      email: profile.email,
+      providers: [
+        {
+          provider: profile.provider,
+          providerId: profile.providerId,
+          accessToken: profile.accessToken,
+          refreshToken: profile.refreshToken,
+          linkedAt: new Date(),
+        },
+      ],
+    };
+  }
+
+  private async updateProviderTokens(
+    userId: string,
+    provider: string,
+    accessToken: string,
+    refreshToken?: string
+  ): Promise<void> {
+    // TODO: Update tokens in database
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(oauthPath, 'oauth.service.ts'), oauthServiceContent);
+    // OAuth Controller
+    const oauthControllerContent = `import {
+  Controller,
+  Get,
+  UseGuards,
+  Req,
+  Res,
+  Query,
+  HttpStatus,
+} from "@nestjs/common";
+import { ApiTags, ApiOperation, ApiExcludeEndpoint } from "@nestjs/swagger";
+import { Response } from "express";
+import { GoogleAuthGuard, GitHubAuthGuard } from "./guards/oauth.guard";
+import { OAuthService } from "./oauth.service";
+import { OAuthProfile } from "./oauth.types";
+
+@ApiTags("OAuth")
+@Controller("auth")
+export class OAuthController {
+  constructor(private oauthService: OAuthService) {}
+
+  // Google OAuth
+  @Get("google")
+  @UseGuards(GoogleAuthGuard)
+  @ApiOperation({ summary: "Initiate Google OAuth login" })
+  googleLogin() {
+    // Guard redirects to Google
+  }
+
+  @Get("google/callback")
+  @UseGuards(GoogleAuthGuard)
+  @ApiExcludeEndpoint()
+  async googleCallback(@Req() req: any, @Res() res: Response) {
+    return this.handleCallback(req.user, res);
+  }
+
+  // GitHub OAuth
+  @Get("github")
+  @UseGuards(GitHubAuthGuard)
+  @ApiOperation({ summary: "Initiate GitHub OAuth login" })
+  githubLogin() {
+    // Guard redirects to GitHub
+  }
+
+  @Get("github/callback")
+  @UseGuards(GitHubAuthGuard)
+  @ApiExcludeEndpoint()
+  async githubCallback(@Req() req: any, @Res() res: Response) {
+    return this.handleCallback(req.user, res);
+  }
+
+  /**
+   * Common callback handler
+   */
+  private async handleCallback(profile: OAuthProfile, res: Response) {
+    try {
+      const { user, accessToken, isNewUser } =
+        await this.oauthService.handleOAuthLogin(profile);
+
+      // Redirect to frontend with token
+      const frontendUrl = process.env.FRONTEND_URL || "http://localhost:3000";
+      const redirectUrl = new URL("/auth/callback", frontendUrl);
+      redirectUrl.searchParams.set("token", accessToken);
+      redirectUrl.searchParams.set("isNewUser", String(isNewUser));
+
+      return res.redirect(redirectUrl.toString());
+    } catch (error) {
+      const frontendUrl = process.env.FRONTEND_URL || "http://localhost:3000";
+      const errorUrl = new URL("/auth/error", frontendUrl);
+      errorUrl.searchParams.set("error", "oauth_failed");
+
+      return res.redirect(errorUrl.toString());
+    }
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(oauthPath, 'oauth.controller.ts'), oauthControllerContent);
+    // OAuth Module
+    const oauthModuleContent = `import { Module } from "@nestjs/common";
+import { PassportModule } from "@nestjs/passport";
+import { JwtModule } from "@nestjs/jwt";
+import { GoogleStrategy } from "./strategies/google.strategy";
+import { GitHubStrategy } from "./strategies/github.strategy";
+import { OAuthService } from "./oauth.service";
+import { OAuthController } from "./oauth.controller";
+
+@Module({
+  imports: [
+    PassportModule.register({ session: false }),
+    JwtModule.register({
+      secret: process.env.JWT_SECRET,
+      signOptions: { expiresIn: "7d" },
+    }),
+  ],
+  controllers: [OAuthController],
+  providers: [
+    OAuthService,
+    GoogleStrategy,
+    GitHubStrategy,
+  ],
+  exports: [OAuthService],
+})
+export class OAuthModule {}
+`;
+    await (0, file_utils_1.writeFile)(path.join(oauthPath, 'oauth.module.ts'), oauthModuleContent);
+    // Index exports
+    await (0, file_utils_1.writeFile)(path.join(oauthPath, 'index.ts'), `export * from "./oauth.types";
+export * from "./oauth.service";
+export * from "./oauth.controller";
+export * from "./oauth.module";
+export * from "./strategies/google.strategy";
+export * from "./strategies/github.strategy";
+export * from "./guards/oauth.guard";
+`);
+    await (0, file_utils_1.writeFile)(path.join(oauthPath, 'strategies/index.ts'), `export * from "./google.strategy";
+export * from "./github.strategy";
+`);
+    await (0, file_utils_1.writeFile)(path.join(oauthPath, 'guards/index.ts'), `export * from "./oauth.guard";
+`);
+    console.log(chalk_1.default.green('  ✓ OAuth types and interfaces'));
+    console.log(chalk_1.default.green('  ✓ Google OAuth strategy'));
+    console.log(chalk_1.default.green('  ✓ GitHub OAuth strategy'));
+    console.log(chalk_1.default.green('  ✓ OAuth guards'));
+    console.log(chalk_1.default.green('  ✓ OAuth service (login, link/unlink providers)'));
+    console.log(chalk_1.default.green('  ✓ OAuth controller with callbacks'));
+    console.log(chalk_1.default.green('  ✓ OAuth module'));
+}
+//# sourceMappingURL=oauth2.recipe.js.map

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

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

package/dist/commands/recipes/websocket.recipe.d.ts

@@ -0,0 +1 @@
+export declare function applyWebSocketRecipe(basePath: string): Promise<void>;