nestcraftx 0.3.0 → 1.0.0

package/utils/generators/infrastructure/middlewareGenerator.js

@@ -33,42 +33,10 @@ const { createDirectory, createFile, updateFile } = require("../../file-system")
  * @returns {string}
  */
 function getExceptionFilterContent(orm) {
+  let dbSpecificChecks = "";
   if (orm === "prisma") {
-    return `
-import {
-  ExceptionFilter,
-  Catch,
-  ArgumentsHost,
-  HttpException,
-  HttpStatus,
-  Logger,
-} from '@nestjs/common';
-import { Request, Response } from 'express';
-
-@Catch()
-export class AllExceptionsFilter implements ExceptionFilter {
-  private readonly logger = new Logger(AllExceptionsFilter.name);
-
-  catch(exception: unknown, host: ArgumentsHost) {
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse<Response>();
-    const request = ctx.getRequest<Request>();
-
-    let status = HttpStatus.INTERNAL_SERVER_ERROR;
-    let message: string | string[] = 'Internal server error';
-    let errorDetails: any = null;
-
-    if (exception instanceof HttpException) {
-      status = exception.getStatus();
-      const res = exception.getResponse();
-      if (typeof res === 'string') {
-        message = res;
-      } else if (typeof res === 'object' && res !== null) {
-        const resObj = res as any;
-        message = resObj.message || resObj.error || 'HttpException';
-        errorDetails = resObj;
-      }
-    } else if (
+    dbSpecificChecks = `
+    else if (
       typeof exception === 'object' &&
       exception &&
       exception.constructor &&
@@ -78,75 +46,13 @@ export class AllExceptionsFilter implements ExceptionFilter {
       )
     ) {
       status = HttpStatus.BAD_REQUEST;
-      message = (exception as any).message || 'Prisma error';
+      message = (exception as any).message || 'Prisma database error';
+      errorResponseName = exception.constructor.name;
       errorDetails = exception;
-    } else if (exception instanceof Error) {
-      message = exception.message;
-      errorDetails = {
-        name: exception.name,
-        stack: exception.stack,
-      };
-    } else {
-      message = 'Une erreur inattendue est survenue';
-      errorDetails = exception;
-    }
-
-    if (process.env.NODE_ENV !== 'production') {
-      this.logger.error(
-        \`Exception on \${request.method} \${request.url}\`,
-        JSON.stringify({ message, status, errorDetails, exception }),
-      );
-    }
-
-    response.status(status).json({
-      statusCode: status,
-      timestamp: new Date().toISOString(),
-      path: request.url,
-      method: request.method,
-      message,
-      error: errorDetails,
-    });
-  }
-}
-`.trim();
-  }
-
-  if (orm === "mongoose") {
-    return `
-import {
-  ExceptionFilter,
-  Catch,
-  ArgumentsHost,
-  HttpException,
-  HttpStatus,
-  Logger,
-} from '@nestjs/common';
-import { Request, Response } from 'express';
-
-@Catch()
-export class AllExceptionsFilter implements ExceptionFilter {
-  private readonly logger = new Logger(AllExceptionsFilter.name);
-
-  catch(exception: unknown, host: ArgumentsHost) {
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse<Response>();
-    const request = ctx.getRequest<Request>();
-
-    let status = HttpStatus.INTERNAL_SERVER_ERROR;
-    let message: string | string[] = 'Internal server error';
-    let errorDetails: any = null;
-
-    if (exception instanceof HttpException) {
-      status = exception.getStatus();
-      const res = exception.getResponse();
-      if (typeof res === 'string') {
-        message = res;
-      } else if (typeof res === 'object' && res !== null) {
-        const resObj = res as any;
-        message = resObj.message || resObj.error || 'HttpException';
-        errorDetails = resObj;
-      }
-    } else if (
+    }`;
+  } else if (orm === "mongoose") {
+    dbSpecificChecks = `
+    else if (
       typeof exception === 'object' &&
       exception &&
       'name' in exception &&
@@ -156,75 +62,78 @@ export class AllExceptionsFilter implements ExceptionFilter {
       )
     ) {
       status = HttpStatus.BAD_REQUEST;
-      message = (exception as any).message || 'MongoDB error';
+      message = (exception as any).message || 'Mongoose database error';
+      errorResponseName = (exception as any).name;
       errorDetails = exception;
-    } else if (exception instanceof Error) {
-      message = exception.message;
-      errorDetails = {
-        name: exception.name,
-        stack: exception.stack,
-      };
-    } else {
-      message = 'Une erreur inattendue est survenue';
+    }`;
+  } else if (orm === "typeorm") {
+    dbSpecificChecks = `
+    else if (
+      typeof exception === 'object' &&
+      exception &&
+      'name' in exception &&
+      (
+        (exception as any).name === 'QueryFailedError' ||
+        (exception as any).name === 'EntityNotFoundError' ||
+        (exception as any).name === 'CannotCreateEntityIdMapError'
+      )
+    ) {
+      status = HttpStatus.BAD_REQUEST;
+      message = (exception as any).message || 'TypeORM database error';
+      errorResponseName = (exception as any).name;
+      errorDetails = exception;
+    }`;
+  } else if (orm === "sequelize") {
+    dbSpecificChecks = `
+    else if (
+      typeof exception === 'object' &&
+      exception &&
+      exception.constructor &&
+      (
+        exception.constructor.name === 'SequelizeDatabaseError' ||
+        exception.constructor.name === 'SequelizeValidationError'
+      )
+    ) {
+      status = HttpStatus.BAD_REQUEST;
+      message = (exception as any).message || 'Sequelize database error';
+      errorResponseName = exception.constructor.name;
+      errorDetails = exception;
+    }`;
+  } else {
+    // fallback global / universal
+    dbSpecificChecks = `
+    // Prisma
+    else if (
+      typeof exception === 'object' &&
+      exception &&
+      exception.constructor &&
+      (
+        exception.constructor.name === 'PrismaClientKnownRequestError' ||
+        exception.constructor.name === 'PrismaClientValidationError'
+      )
+    ) {
+      status = HttpStatus.BAD_REQUEST;
+      message = (exception as any).message || 'Prisma database error';
+      errorResponseName = exception.constructor.name;
       errorDetails = exception;
     }
-
-    if (process.env.NODE_ENV !== 'production') {
-      this.logger.error(
-        \`Exception on \${request.method} \${request.url}\`,
-        JSON.stringify({ message, status, errorDetails, exception }),
-      );
+    // Mongoose/Mongo
+    else if (
+      typeof exception === 'object' &&
+      exception &&
+      'name' in exception &&
+      (
+        (exception as any).name === 'MongoError' ||
+        (exception as any).name === 'MongooseError'
+      )
+    ) {
+      status = HttpStatus.BAD_REQUEST;
+      message = (exception as any).message || 'Mongoose database error';
+      errorResponseName = (exception as any).name;
+      errorDetails = exception;
     }
-
-    response.status(status).json({
-      statusCode: status,
-      timestamp: new Date().toISOString(),
-      path: request.url,
-      method: request.method,
-      message,
-      error: errorDetails,
-    });
-  }
-}
-`.trim();
-  }
-
-  if (orm === "typeorm") {
-    return `
-import {
-  ExceptionFilter,
-  Catch,
-  ArgumentsHost,
-  HttpException,
-  HttpStatus,
-  Logger,
-} from '@nestjs/common';
-import { Request, Response } from 'express';
-
-@Catch()
-export class AllExceptionsFilter implements ExceptionFilter {
-  private readonly logger = new Logger(AllExceptionsFilter.name);
-
-  catch(exception: unknown, host: ArgumentsHost) {
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse<Response>();
-    const request = ctx.getRequest<Request>();
-
-    let status = HttpStatus.INTERNAL_SERVER_ERROR;
-    let message: string | string[] = 'Internal server error';
-    let errorDetails: any = null;
-
-    if (exception instanceof HttpException) {
-      status = exception.getStatus();
-      const res = exception.getResponse();
-      if (typeof res === 'string') {
-        message = res;
-      } else if (typeof res === 'object' && res !== null) {
-        const resObj = res as any;
-        message = resObj.message || resObj.error || 'HttpException';
-        errorDetails = resObj;
-      }
-    } else if (
+    // TypeORM
+    else if (
       typeof exception === 'object' &&
       exception &&
       'name' in exception &&
@@ -235,75 +144,12 @@ export class AllExceptionsFilter implements ExceptionFilter {
       )
     ) {
       status = HttpStatus.BAD_REQUEST;
-      message = (exception as any).message || 'TypeORM error';
-      errorDetails = exception;
-    } else if (exception instanceof Error) {
-      message = exception.message;
-      errorDetails = {
-        name: exception.name,
-        stack: exception.stack,
-      };
-    } else {
-      message = 'Une erreur inattendue est survenue';
+      message = (exception as any).message || 'TypeORM database error';
+      errorResponseName = (exception as any).name;
       errorDetails = exception;
     }
-
-    if (process.env.NODE_ENV !== 'production') {
-      this.logger.error(
-        \`Exception on \${request.method} \${request.url}\`,
-        JSON.stringify({ message, status, errorDetails, exception }),
-      );
-    }
-
-    response.status(status).json({
-      statusCode: status,
-      timestamp: new Date().toISOString(),
-      path: request.url,
-      method: request.method,
-      message,
-      error: errorDetails,
-    });
-  }
-}
-`.trim();
-  }
-
-  if (orm === "sequelize") {
-    return `
-import {
-  ExceptionFilter,
-  Catch,
-  ArgumentsHost,
-  HttpException,
-  HttpStatus,
-  Logger,
-} from '@nestjs/common';
-import { Request, Response } from 'express';
-
-@Catch()
-export class AllExceptionsFilter implements ExceptionFilter {
-  private readonly logger = new Logger(AllExceptionsFilter.name);
-
-  catch(exception: unknown, host: ArgumentsHost) {
-    const ctx = host.switchToHttp();
-    const response = ctx.getResponse<Response>();
-    const request = ctx.getRequest<Request>();
-
-    let status = HttpStatus.INTERNAL_SERVER_ERROR;
-    let message: string | string[] = 'Internal server error';
-    let errorDetails: any = null;
-
-    if (exception instanceof HttpException) {
-      status = exception.getStatus();
-      const res = exception.getResponse();
-      if (typeof res === 'string') {
-        message = res;
-      } else if (typeof res === 'object' && res !== null) {
-        const resObj = res as any;
-        message = resObj.message || resObj.error || 'HttpException';
-        errorDetails = resObj;
-      }
-    } else if (
+    // Sequelize
+    else if (
       typeof exception === 'object' &&
       exception &&
       exception.constructor &&
@@ -313,40 +159,12 @@ export class AllExceptionsFilter implements ExceptionFilter {
       )
     ) {
       status = HttpStatus.BAD_REQUEST;
-      message = (exception as any).message || 'Sequelize error';
-      errorDetails = exception;
-    } else if (exception instanceof Error) {
-      message = exception.message;
-      errorDetails = {
-        name: exception.name,
-        stack: exception.stack,
-      };
-    } else {
-      message = 'Une erreur inattendue est survenue';
+      message = (exception as any).message || 'Sequelize database error';
+      errorResponseName = exception.constructor.name;
       errorDetails = exception;
-    }
-
-    if (process.env.NODE_ENV !== 'production') {
-      this.logger.error(
-        \`Exception on \${request.method} \${request.url}\`,
-        JSON.stringify({ message, status, errorDetails, exception }),
-      );
-    }
-
-    response.status(status).json({
-      statusCode: status,
-      timestamp: new Date().toISOString(),
-      path: request.url,
-      method: request.method,
-      message,
-      error: errorDetails,
-    });
-  }
-}
-`.trim();
+    }`;
   }
 
-  // Version universelle (multi-ORM / fallback)
   return `
 import {
   ExceptionFilter,
@@ -358,6 +176,15 @@ import {
 } from '@nestjs/common';
 import { Request, Response } from 'express';
 
+export interface ErrorResponse {
+  statusCode: number;
+  timestamp: string;
+  path: string;
+  method: string;
+  message: string | string[];
+  error: string;
+}
+
 @Catch()
 export class AllExceptionsFilter implements ExceptionFilter {
   private readonly logger = new Logger(AllExceptionsFilter.name);
@@ -369,11 +196,13 @@ export class AllExceptionsFilter implements ExceptionFilter {
 
     let status = HttpStatus.INTERNAL_SERVER_ERROR;
     let message: string | string[] = 'Internal server error';
+    let errorResponseName = 'InternalServerError';
     let errorDetails: any = null;
 
     if (exception instanceof HttpException) {
       status = exception.getStatus();
       const res = exception.getResponse();
+      errorResponseName = exception.name || 'HttpException';
       if (typeof res === 'string') {
         message = res;
       } else if (typeof res === 'object' && res !== null) {
@@ -381,51 +210,10 @@ export class AllExceptionsFilter implements ExceptionFilter {
         message = resObj.message || resObj.error || 'HttpException';
         errorDetails = resObj;
       }
-    }
-    // Prisma
-    else if (
-      typeof exception === 'object' &&
-      exception &&
-      exception.constructor &&
-      (
-        exception.constructor.name === 'PrismaClientKnownRequestError' ||
-        exception.constructor.name === 'PrismaClientValidationError'
-      )
-    ) {
-      status = HttpStatus.BAD_REQUEST;
-      message = (exception as any).message || 'Prisma error';
-      errorDetails = exception;
-    }
-    // Mongoose/Mongo
-    else if (
-      typeof exception === 'object' &&
-      exception &&
-      'name' in exception &&
-      (
-        (exception as any).name === 'MongoError' ||
-        (exception as any).name === 'MongooseError'
-      )
-    ) {
-      status = HttpStatus.BAD_REQUEST;
-      message = (exception as any).message || 'MongoDB error';
-      errorDetails = exception;
-    }
-    // Sequelize
-    else if (
-      typeof exception === 'object' &&
-      exception &&
-      exception.constructor &&
-      (
-        exception.constructor.name === 'SequelizeDatabaseError' ||
-        exception.constructor.name === 'SequelizeValidationError'
-      )
-    ) {
-      status = HttpStatus.BAD_REQUEST;
-      message = (exception as any).message || 'Sequelize error';
-      errorDetails = exception;
-    }
+    }${dbSpecificChecks}
     else if (exception instanceof Error) {
       message = exception.message;
+      errorResponseName = exception.name;
       errorDetails = {
         name: exception.name,
         stack: exception.stack,
@@ -436,18 +224,27 @@ export class AllExceptionsFilter implements ExceptionFilter {
     }
 
     this.logger.error(
-      \`Exception on \${request.method} \${request.url}\`,
-      JSON.stringify({ message, status, errorDetails, exception }),
+      \`[\${request.method}] \${request.url} - Error status: \${status}\`,
+      exception instanceof Error ? exception.stack : JSON.stringify(exception),
     );
 
-    response.status(status).json({
+    const isProduction = process.env.NODE_ENV === 'production';
+    const payload: ErrorResponse = {
       statusCode: status,
       timestamp: new Date().toISOString(),
       path: request.url,
       method: request.method,
-      message,
-      error: errorDetails,
-    });
+      message: (status === HttpStatus.INTERNAL_SERVER_ERROR && isProduction)
+        ? 'Internal server error'
+        : message,
+      error: isProduction ? errorResponseName : (errorDetails?.error || errorResponseName),
+    };
+
+    if (!isProduction && errorDetails) {
+      (payload as any).details = errorDetails;
+    }
+
+    response.status(status).json(payload);
   }
 }
 `.trim();

package/utils/generators/infrastructure/mongooseSchemaGenerator.js

@@ -119,6 +119,7 @@ async function generateMongooseSchemaFileContent(
     "number",
     "int",
     "float",
+    "decimal",
     "boolean",
     "date",
     "uuid",
@@ -144,35 +145,67 @@ async function generateMongooseSchemaFileContent(
 
       // 2. Mapping des types CLI -> TypeScript/Mongoose
       let tsType = "string";
-      let propOptions = "required: true";
+      let propOpts = [];
 
       switch (rawType) {
         case "text":
         case "uuid":
         case "string":
           tsType = "string";
+          propOpts.push("type: String");
           break;
         case "int":
         case "number":
         case "float":
         case "decimal":
           tsType = "number";
+          propOpts.push("type: Number");
           break;
         case "boolean":
           tsType = "boolean";
+          propOpts.push("type: Boolean");
           break;
         case "date":
           tsType = "Date";
+          propOpts.push("type: Date");
           break;
         case "json":
           tsType = "Record<string, any>";
-          propOptions = "type: Object, required: true";
+          propOpts.push("type: Object");
           break;
         default:
           tsType = "any";
       }
 
-      return `  @Prop({ ${propOptions} })\n  ${fieldName}: ${tsType};`;
+      const isRequired = f.nullable !== undefined ? !f.nullable : (fieldName.toLowerCase() !== "isactive" && fieldName.toLowerCase() !== "password");
+      if (isRequired) {
+        propOpts.push("required: true");
+      }
+      if (f.unique) {
+        propOpts.push("unique: true");
+      }
+      if (f.default !== undefined && f.default !== null && f.default !== "") {
+        let defaultVal = f.default;
+        if (typeof defaultVal === "string") {
+          if (defaultVal === "true") defaultVal = true;
+          else if (defaultVal === "false") defaultVal = false;
+          else if (defaultVal.toLowerCase() === "now" || defaultVal.toLowerCase() === "now()") {
+            defaultVal = "Date.now";
+          } else if (!isNaN(defaultVal) && defaultVal.trim() !== "") {
+            defaultVal = Number(defaultVal);
+          }
+        }
+        if (defaultVal === "Date.now") {
+          propOpts.push("default: Date.now");
+        } else if (typeof defaultVal === "boolean" || typeof defaultVal === "number") {
+          propOpts.push(`default: ${defaultVal}`);
+        } else {
+          propOpts.push(`default: '${defaultVal}'`);
+        }
+      }
+
+      const propOptions = propOpts.join(", ");
+      return `  @Prop({ ${propOptions} })\n  ${fieldName}${f.nullable ? "?" : ""}: ${tsType};`;
     });
 
   const allFields = [...new Set([...directFields, ...dynamicRelations])].join(
@@ -193,4 +226,81 @@ ${allFields}
 export const ${entityName}Schema = SchemaFactory.createForClass(${entityName});`.trim();
 }
 
-module.exports = { generateMongooseSchemaFileContent };
+/**
+ * Ajoute une relation entre deux schémas Mongoose EXISTANTS.
+ * Patche les deux fichiers .schema.ts pour ajouter les champs de référence.
+ *
+ * @param {string} source - Nom du module source (ex: "post")
+ * @param {string} target - Nom du module cible (ex: "user")
+ * @param {string} relationType - "n-1" | "1-n" | "1-1" | "n-n"
+ * @param {string} mode - "full" | "light"
+ */
+async function addMongooseRelation(source, target, relationType, mode = "full") {
+  const fs = require("fs");
+  const { updateFile } = require("../../userInput");
+
+  const sourceLow = source.toLowerCase();
+  const targetLow = target.toLowerCase();
+  const sourceCap = capitalize(source);
+  const targetCap = capitalize(target);
+
+  const isFull = mode === "full";
+
+  const sourceSchemaPath = isFull
+    ? `src/${sourceLow}/infrastructure/persistence/mongoose/${sourceLow}.schema.ts`
+    : `src/${sourceLow}/entities/${sourceLow}.schema.ts`;
+
+  const targetSchemaPath = isFull
+    ? `src/${targetLow}/infrastructure/persistence/mongoose/${targetLow}.schema.ts`
+    : `src/${targetLow}/entities/${targetLow}.schema.ts`;
+
+  // --- Champs à injecter dans SOURCE ---
+  let sourceField = "";
+  switch (relationType) {
+    case "n-1":
+    case "1-1":
+      // FK : référence vers un document cible
+      sourceField = `\n  @Prop({ type: 'ObjectId', ref: '${targetCap}' })\n  ${targetLow}Id: string;\n`;
+      break;
+    case "1-n":
+    case "n-n":
+      // Tableau de références vers la cible
+      sourceField = `\n  @Prop([{ type: 'ObjectId', ref: '${targetCap}' }])\n  ${targetLow}Ids: string[];\n`;
+      break;
+  }
+
+  // --- Champs inverses à injecter dans TARGET ---
+  let targetField = "";
+  switch (relationType) {
+    case "n-1":
+    case "n-n":
+      // Le target a un tableau de sources
+      targetField = `\n  @Prop([{ type: 'ObjectId', ref: '${sourceCap}' }])\n  ${sourceLow}Ids: string[];\n`;
+      break;
+    case "1-n":
+    case "1-1":
+      // Le target a une référence unique vers source
+      targetField = `\n  @Prop({ type: 'ObjectId', ref: '${sourceCap}' })\n  ${sourceLow}Id: string;\n`;
+      break;
+  }
+
+  // Patch source schema
+  if (fs.existsSync(sourceSchemaPath) && sourceField) {
+    await updateFile({
+      path: sourceSchemaPath,
+      pattern: new RegExp(`(export class ${sourceCap} \\{)`),
+      replacement: `$1${sourceField}`,
+    });
+  }
+
+  // Patch target schema
+  if (fs.existsSync(targetSchemaPath) && targetField) {
+    await updateFile({
+      path: targetSchemaPath,
+      pattern: new RegExp(`(export class ${targetCap} \\{)`),
+      replacement: `$1${targetField}`,
+    });
+  }
+}
+
+module.exports = { generateMongooseSchemaFileContent, addMongooseRelation };