nestjs-ddd-cli 2.2.0 → 3.2.1

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

@@ -0,0 +1,383 @@
+"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.applyMiddlewareRecipe = applyMiddlewareRecipe;
+const path = __importStar(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const file_utils_1 = require("../../utils/file.utils");
+async function applyMiddlewareRecipe(basePath) {
+    const sharedPath = path.join(basePath, 'src/shared');
+    const middlewarePath = path.join(sharedPath, 'middleware');
+    const guardsPath = path.join(sharedPath, 'guards');
+    const interceptorsPath = path.join(sharedPath, 'interceptors');
+    await (0, file_utils_1.ensureDir)(middlewarePath);
+    await (0, file_utils_1.ensureDir)(guardsPath);
+    await (0, file_utils_1.ensureDir)(interceptorsPath);
+    // Request Logger Middleware
+    const loggerMiddlewareContent = `import { Injectable, NestMiddleware, Logger } from "@nestjs/common";
+import { Request, Response, NextFunction } from "express";
+import { v4 as uuid } from "uuid";
+
+@Injectable()
+export class RequestLoggerMiddleware implements NestMiddleware {
+  private readonly logger = new Logger("HTTP");
+
+  use(req: Request, res: Response, next: NextFunction) {
+    const requestId = (req.headers["x-request-id"] as string) || uuid();
+    const startTime = Date.now();
+    const { method, originalUrl, ip } = req;
+    const userAgent = req.get("user-agent") || "";
+
+    // Attach request ID to request object
+    (req as any).requestId = requestId;
+    res.setHeader("X-Request-Id", requestId);
+
+    // Log request
+    this.logger.log(\`--> \${method} \${originalUrl} [ID: \${requestId}]\`);
+
+    // Log response when finished
+    res.on("finish", () => {
+      const duration = Date.now() - startTime;
+      const { statusCode } = res;
+      const contentLength = res.get("content-length") || 0;
+
+      const logLevel = statusCode >= 500 ? "error" : statusCode >= 400 ? "warn" : "log";
+
+      this.logger[\`\${logLevel}\`](
+        \`<-- \${method} \${originalUrl} \${statusCode} \${duration}ms \${contentLength}b [ID: \${requestId}]\`
+      );
+    });
+
+    next();
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(middlewarePath, 'request-logger.middleware.ts'), loggerMiddlewareContent);
+    // Correlation ID Middleware
+    const correlationMiddlewareContent = `import { Injectable, NestMiddleware } from "@nestjs/common";
+import { Request, Response, NextFunction } from "express";
+import { v4 as uuid } from "uuid";
+import { AsyncLocalStorage } from "async_hooks";
+
+export interface CorrelationContext {
+  correlationId: string;
+  requestId: string;
+  userId?: string;
+  tenantId?: string;
+}
+
+export const correlationStorage = new AsyncLocalStorage<CorrelationContext>();
+
+@Injectable()
+export class CorrelationIdMiddleware implements NestMiddleware {
+  use(req: Request, res: Response, next: NextFunction) {
+    const correlationId = (req.headers["x-correlation-id"] as string) || uuid();
+    const requestId = (req.headers["x-request-id"] as string) || uuid();
+
+    const context: CorrelationContext = {
+      correlationId,
+      requestId,
+      userId: (req as any).user?.id,
+      tenantId: (req as any).tenantId,
+    };
+
+    res.setHeader("X-Correlation-Id", correlationId);
+    res.setHeader("X-Request-Id", requestId);
+
+    correlationStorage.run(context, () => next());
+  }
+}
+
+export function getCorrelationContext(): CorrelationContext | undefined {
+  return correlationStorage.getStore();
+}
+
+export function getCorrelationId(): string | undefined {
+  return correlationStorage.getStore()?.correlationId;
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(middlewarePath, 'correlation-id.middleware.ts'), correlationMiddlewareContent);
+    // Permission Guard
+    const permissionGuardContent = `import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+
+export const PERMISSIONS_KEY = "permissions";
+export const Permissions = (...permissions: string[]) =>
+  Reflect.metadata(PERMISSIONS_KEY, permissions);
+
+@Injectable()
+export class PermissionGuard implements CanActivate {
+  constructor(private reflector: Reflector) {}
+
+  canActivate(context: ExecutionContext): boolean {
+    const requiredPermissions = this.reflector.getAllAndOverride<string[]>(
+      PERMISSIONS_KEY,
+      [context.getHandler(), context.getClass()]
+    );
+
+    if (!requiredPermissions || requiredPermissions.length === 0) {
+      return true;
+    }
+
+    const { user } = context.switchToHttp().getRequest();
+
+    if (!user) {
+      throw new ForbiddenException("User not authenticated");
+    }
+
+    const userPermissions: string[] = user.permissions || [];
+    const hasPermission = requiredPermissions.every((permission) =>
+      userPermissions.includes(permission)
+    );
+
+    if (!hasPermission) {
+      throw new ForbiddenException(
+        \`Missing required permissions: \${requiredPermissions.join(", ")}\`
+      );
+    }
+
+    return true;
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(guardsPath, 'permission.guard.ts'), permissionGuardContent);
+    // Resource Owner Guard
+    const resourceOwnerGuardContent = `import { Injectable, CanActivate, ExecutionContext, ForbiddenException } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
+
+export const RESOURCE_OWNER_KEY = "resource_owner";
+export const ResourceOwner = (paramName: string = "id", userField: string = "userId") =>
+  Reflect.metadata(RESOURCE_OWNER_KEY, { paramName, userField });
+
+@Injectable()
+export class ResourceOwnerGuard implements CanActivate {
+  constructor(private reflector: Reflector) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const config = this.reflector.get<{ paramName: string; userField: string }>(
+      RESOURCE_OWNER_KEY,
+      context.getHandler()
+    );
+
+    if (!config) return true;
+
+    const request = context.switchToHttp().getRequest();
+    const user = request.user;
+
+    if (!user) {
+      throw new ForbiddenException("User not authenticated");
+    }
+
+    // Admin bypass
+    if (user.roles?.includes("admin")) return true;
+
+    const resourceId = request.params[config.paramName];
+    const userId = user.id;
+
+    // You should inject and use your repository here
+    // This is a placeholder - implement actual resource lookup
+    const resource = request.resource; // Assume loaded by previous middleware/interceptor
+
+    if (resource && resource[config.userField] !== userId) {
+      throw new ForbiddenException("You do not own this resource");
+    }
+
+    return true;
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(guardsPath, 'resource-owner.guard.ts'), resourceOwnerGuardContent);
+    // Transform Response Interceptor
+    const transformInterceptorContent = `import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+} from "@nestjs/common";
+import { Observable } from "rxjs";
+import { map } from "rxjs/operators";
+import { Reflector } from "@nestjs/core";
+
+export interface StandardResponse<T> {
+  success: boolean;
+  data: T;
+  meta?: {
+    timestamp: string;
+    requestId?: string;
+    [key: string]: any;
+  };
+}
+
+export const SKIP_TRANSFORM_KEY = "skip_transform";
+export const SkipTransform = () => Reflect.metadata(SKIP_TRANSFORM_KEY, true);
+
+@Injectable()
+export class TransformResponseInterceptor<T>
+  implements NestInterceptor<T, StandardResponse<T>>
+{
+  constructor(private reflector: Reflector) {}
+
+  intercept(
+    context: ExecutionContext,
+    next: CallHandler
+  ): Observable<StandardResponse<T>> {
+    const skipTransform = this.reflector.get<boolean>(
+      SKIP_TRANSFORM_KEY,
+      context.getHandler()
+    );
+
+    if (skipTransform) {
+      return next.handle();
+    }
+
+    const request = context.switchToHttp().getRequest();
+
+    return next.handle().pipe(
+      map((data) => ({
+        success: true,
+        data,
+        meta: {
+          timestamp: new Date().toISOString(),
+          requestId: request.requestId || request.headers["x-request-id"],
+        },
+      }))
+    );
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(interceptorsPath, 'transform-response.interceptor.ts'), transformInterceptorContent);
+    // Timing Interceptor
+    const timingInterceptorContent = `import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+  Logger,
+} from "@nestjs/common";
+import { Observable } from "rxjs";
+import { tap } from "rxjs/operators";
+
+@Injectable()
+export class TimingInterceptor implements NestInterceptor {
+  private readonly logger = new Logger("Timing");
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const request = context.switchToHttp().getRequest();
+    const response = context.switchToHttp().getResponse();
+    const { method, url } = request;
+    const startTime = Date.now();
+
+    return next.handle().pipe(
+      tap({
+        next: () => {
+          const duration = Date.now() - startTime;
+          response.setHeader("X-Response-Time", \`\${duration}ms\`);
+
+          if (duration > 1000) {
+            this.logger.warn(\`Slow request: \${method} \${url} took \${duration}ms\`);
+          }
+        },
+        error: () => {
+          const duration = Date.now() - startTime;
+          response.setHeader("X-Response-Time", \`\${duration}ms\`);
+        },
+      })
+    );
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(interceptorsPath, 'timing.interceptor.ts'), timingInterceptorContent);
+    // Timeout Interceptor
+    const timeoutInterceptorContent = `import {
+  Injectable,
+  NestInterceptor,
+  ExecutionContext,
+  CallHandler,
+  RequestTimeoutException,
+} from "@nestjs/common";
+import { Observable, throwError, TimeoutError } from "rxjs";
+import { catchError, timeout } from "rxjs/operators";
+import { Reflector } from "@nestjs/core";
+
+export const TIMEOUT_KEY = "request_timeout";
+export const SetTimeout = (ms: number) => Reflect.metadata(TIMEOUT_KEY, ms);
+
+@Injectable()
+export class TimeoutInterceptor implements NestInterceptor {
+  constructor(private reflector: Reflector) {}
+
+  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
+    const timeoutMs =
+      this.reflector.get<number>(TIMEOUT_KEY, context.getHandler()) ||
+      parseInt(process.env.REQUEST_TIMEOUT || "30000", 10);
+
+    return next.handle().pipe(
+      timeout(timeoutMs),
+      catchError((err) => {
+        if (err instanceof TimeoutError) {
+          return throwError(
+            () => new RequestTimeoutException(\`Request timeout after \${timeoutMs}ms\`)
+          );
+        }
+        return throwError(() => err);
+      })
+    );
+  }
+}
+`;
+    await (0, file_utils_1.writeFile)(path.join(interceptorsPath, 'timeout.interceptor.ts'), timeoutInterceptorContent);
+    // Index exports
+    await (0, file_utils_1.writeFile)(path.join(middlewarePath, 'index.ts'), `export * from "./request-logger.middleware";
+export * from "./correlation-id.middleware";
+`);
+    await (0, file_utils_1.writeFile)(path.join(guardsPath, 'index.ts'), `export * from "./permission.guard";
+export * from "./resource-owner.guard";
+`);
+    await (0, file_utils_1.writeFile)(path.join(interceptorsPath, 'index.ts'), `export * from "./transform-response.interceptor";
+export * from "./timing.interceptor";
+export * from "./timeout.interceptor";
+`);
+    console.log(chalk_1.default.green('  ✓ Request Logger Middleware'));
+    console.log(chalk_1.default.green('  ✓ Correlation ID Middleware with AsyncLocalStorage'));
+    console.log(chalk_1.default.green('  ✓ Permission Guard with @Permissions decorator'));
+    console.log(chalk_1.default.green('  ✓ Resource Owner Guard'));
+    console.log(chalk_1.default.green('  ✓ Transform Response Interceptor'));
+    console.log(chalk_1.default.green('  ✓ Timing Interceptor'));
+    console.log(chalk_1.default.green('  ✓ Timeout Interceptor'));
+}
+//# sourceMappingURL=middleware.recipe.js.map

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

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

package/dist/commands/recipes/multi-tenancy.recipe.d.ts

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