@lenne.tech/nest-server 11.4.4 → 11.4.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "11.4.4",
+  "version": "11.4.6",
   "description": "Modern, fast, powerful Node.js web framework in TypeScript based on Nest with a GraphQL API and a connection to MongoDB (or other databases).",
   "keywords": [
     "node",

package/src/core/common/decorators/unified-field.decorator.ts

@@ -1,4 +1,5 @@
 import { Field, FieldOptions } from '@nestjs/graphql';
+import { TypeMetadataStorage } from '@nestjs/graphql/dist/schema-builder/storages/type-metadata.storage';
 import { Prop, PropOptions } from '@nestjs/mongoose';
 import { ApiProperty, ApiPropertyOptions } from '@nestjs/swagger';
 import { EnumAllowedTypes } from '@nestjs/swagger/dist/interfaces/schema-object-metadata.interface';
@@ -7,6 +8,7 @@ import {
   IsArray,
   IsBoolean,
   IsDate,
+  IsDefined,
   IsEnum,
   IsNotEmpty,
   IsNumber,
@@ -17,11 +19,21 @@ import {
   ValidateNested,
   ValidationOptions,
 } from 'class-validator';
-import { GraphQLScalarType } from 'graphql';
+import { GraphQLScalarType, isEnumType } from 'graphql';
 
 import { RoleEnum } from '../enums/role.enum';
 import { Restricted, RestrictedType } from './restricted.decorator';
 
+// Registry to store nested type information for validation
+// Key: `${className}.${propertyName}`, Value: nested type constructor
+export const nestedTypeRegistry = new Map<string, any>();
+
+/**
+ * Registry to map enum objects to their names.
+ * This is populated when registerEnumType is called or can be manually populated.
+ */
+export const enumNameRegistry = new Map<any, string>();
+
 export interface UnifiedFieldOptions {
   /** Description used for both Swagger & Gql */
   description?: string;
@@ -128,6 +140,8 @@ export function UnifiedField(opts: UnifiedFieldOptions = {}): PropertyDecorator
       swaggerOpts.nullable = true;
       swaggerOpts.required = false;
     } else {
+      // Use IsDefined to ensure field is present, then IsNotEmpty to ensure it's not empty
+      IsDefined()(target, propertyKey);
       IsNotEmpty()(target, propertyKey);
 
       gqlOpts.nullable = false;
@@ -159,7 +173,18 @@ export function UnifiedField(opts: UnifiedFieldOptions = {}): PropertyDecorator
     if (opts.enum && opts.enum.enum) {
       swaggerOpts.enum = opts.enum.enum;
 
-      if (opts.enum.enumName) {
+      // Set enumName with auto-detection:
+      // - If enumName property doesn't exist at all, auto-detect the name
+      // - If enumName is explicitly set (even to null/undefined), use that value
+      // This allows explicit opts.enum.enumName = undefined to disable auto-detection
+      if (!('enumName' in opts.enum)) {
+        // Property doesn't exist, try auto-detection
+        const autoDetectedName = getEnumName(opts.enum.enum);
+        if (autoDetectedName) {
+          swaggerOpts.enumName = autoDetectedName;
+        }
+      } else {
+        // Property exists (even if undefined/null), use its value
         swaggerOpts.enumName = opts.enum.enumName;
       }
 
@@ -209,10 +234,20 @@ export function UnifiedField(opts: UnifiedFieldOptions = {}): PropertyDecorator
     }
 
     if (!opts.isAny) {
+      // Special handling for Date: needs @Type transformation even though it's "primitive"
+      // This allows ISO date strings to be transformed to Date objects before validation
+      if (baseType === Date) {
+        Type(() => Date)(target, propertyKey);
+      }
       // Check if it's a primitive, if not apply transform
-      if (!isPrimitive(baseType) && !opts.enum && !isGraphQLScalar(baseType)) {
+      else if (!isPrimitive(baseType) && !opts.enum && !isGraphQLScalar(baseType)) {
         Type(() => baseType)(target, propertyKey);
         ValidateNested({ each: isArrayField })(target, propertyKey);
+
+        // Store nested type info in registry for use in MapAndValidatePipe
+        const className = target.constructor.name;
+        const registryKey = `${className}.${String(propertyKey)}`;
+        nestedTypeRegistry.set(registryKey, baseType);
       }
     }
 
@@ -259,11 +294,60 @@ function getBuiltInValidator(
     return null;
   }
   if (each) {
-    return (t, k) => decorator(target, k);
+    return (_t, k) => decorator(target, k);
   }
   return decorator;
 }
 
+/**
+ * Helper function to extract enum name from an enum object
+ * Attempts multiple strategies to find a meaningful name
+ */
+function getEnumName(enumObj: any): string | undefined {
+  // Check if the enum was registered in our custom registry
+  if (enumNameRegistry.has(enumObj)) {
+    return enumNameRegistry.get(enumObj);
+  }
+
+  // Check if it's registered in GraphQL TypeMetadataStorage (most common case with registerEnumType)
+  try {
+    const enumsMetadata = TypeMetadataStorage.getEnumsMetadata();
+    const matchingEnum = enumsMetadata.find((metadata) => metadata.ref === enumObj);
+    if (matchingEnum && matchingEnum.name) {
+      return matchingEnum.name;
+    }
+  } catch (error) {
+    // TypeMetadataStorage might not be initialized yet during bootstrap
+    // This is not an error, we just continue with other strategies
+  }
+
+  // Check if it's a GraphQL enum type
+  if (isEnumType(enumObj)) {
+    return enumObj.name;
+  }
+
+  // Check if the enum object has a name property (some custom implementations)
+  if (enumObj && typeof enumObj === 'object' && 'name' in enumObj && typeof enumObj.name === 'string') {
+    return enumObj.name;
+  }
+
+  // Check if it's a constructor function with a name
+  if (typeof enumObj === 'function' && enumObj.name && enumObj.name !== 'Object') {
+    return enumObj.name;
+  }
+
+  // For regular TypeScript enums, try to find the global variable name
+  // This is a heuristic approach - not guaranteed to work in all cases
+  if (enumObj && typeof enumObj === 'object') {
+    // Check constructor name (though this usually returns 'Object' for enums)
+    if (enumObj.constructor && enumObj.constructor.name && enumObj.constructor.name !== 'Object') {
+      return enumObj.constructor.name;
+    }
+  }
+
+  return undefined;
+}
+
 function isGraphQLScalar(type: any): boolean {
   // CustomScalar check (The CustomScalar interface implements these functions below)
   return (

package/src/core/common/helpers/register-enum.helper.ts

@@ -0,0 +1,93 @@
+import { registerEnumType } from '@nestjs/graphql';
+
+import { enumNameRegistry } from '../decorators/unified-field.decorator';
+
+/**
+ * Interface defining options for the registerEnum helper
+ */
+export interface RegisterEnumOptions<T extends object = any> {
+  /**
+   * Description of the enum
+   */
+  description?: string;
+
+  /**
+   * Whether to register the enum for GraphQL using registerEnumType
+   * @default true
+   */
+  graphql?: boolean;
+
+  /**
+   * Name of the enum (required)
+   */
+  name: string;
+
+  /**
+   * Whether to register the enum in the enumNameRegistry for Swagger/REST
+   * @default true
+   */
+  swagger?: boolean;
+
+  /**
+   * A map of options for the values of the enum (only used for GraphQL)
+   */
+  valuesMap?: Partial<Record<keyof T, { deprecationReason?: string; description?: string }>>;
+}
+
+/**
+ * Registers an enum for both GraphQL and Swagger/REST APIs.
+ *
+ * This is a convenience helper that combines:
+ * - `registerEnumType` from @nestjs/graphql (for GraphQL schema)
+ * - Manual registration in `enumNameRegistry` (for Swagger/OpenAPI)
+ *
+ * @example
+ * ```typescript
+ * export enum StatusEnum {
+ *   ACTIVE = 'active',
+ *   INACTIVE = 'inactive'
+ * }
+ *
+ * // Register for both GraphQL and REST
+ * registerEnum(StatusEnum, {
+ *   name: 'StatusEnum',
+ *   description: 'User status'
+ * });
+ *
+ * // Register only for REST (no GraphQL)
+ * registerEnum(StatusEnum, {
+ *   name: 'StatusEnum',
+ *   graphql: false
+ * });
+ *
+ * // Register only for GraphQL (no REST)
+ * registerEnum(StatusEnum, {
+ *   name: 'StatusEnum',
+ *   swagger: false
+ * });
+ * ```
+ *
+ * @param enumRef - The enum reference to register
+ * @param options - Registration options
+ */
+export function registerEnum<T extends object = any>(enumRef: T, options: RegisterEnumOptions<T>): void {
+  const { description, graphql = true, name, swagger = true, valuesMap } = options;
+
+  if (!name) {
+    throw new Error('Enum name is required for registerEnum');
+  }
+
+  // Register for Swagger/REST if enabled
+  if (swagger) {
+    enumNameRegistry.set(enumRef, name);
+  }
+
+  // Register for GraphQL if enabled
+  if (graphql) {
+    registerEnumType(enumRef, {
+      description,
+      name,
+      valuesMap,
+    });
+  }
+}