@lenne.tech/nest-server 11.4.5 → 11.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "11.4.5",
+  "version": "11.4.7",
   "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';
@@ -18,7 +19,7 @@ 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';
@@ -27,6 +28,12 @@ import { Restricted, RestrictedType } from './restricted.decorator';
 // 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;
@@ -166,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;
       }
 
@@ -276,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,
+    });
+  }
+}

package/src/core/modules/migrate/cli/migrate-cli.ts

@@ -91,7 +91,7 @@ async function listMigrations(options: CliOptions) {
   const stateStore = loadStateStore(options.store);
 
   const runner = new MigrationRunner({
-    migrationsDirectory: options.migrationsDir,
+    migrationsDirectory: path.resolve(process.cwd(), options.migrationsDir),
     stateStore,
   });
 
@@ -255,7 +255,7 @@ async function runDown(options: CliOptions) {
   const stateStore = loadStateStore(options.store);
 
   const runner = new MigrationRunner({
-    migrationsDirectory: options.migrationsDir,
+    migrationsDirectory: path.resolve(process.cwd(), options.migrationsDir),
     stateStore,
   });
 
@@ -270,7 +270,7 @@ async function runUp(options: CliOptions) {
   const stateStore = loadStateStore(options.store);
 
   const runner = new MigrationRunner({
-    migrationsDirectory: options.migrationsDir,
+    migrationsDirectory: path.resolve(process.cwd(), options.migrationsDir),
     stateStore,
   });
 

package/src/core/modules/migrate/helpers/migration.helper.ts

@@ -6,20 +6,64 @@ import * as path from 'path';
  * Migration helper functions for database operations
  */
 
+// Store active connections for auto-cleanup
+const activeConnections = new Set<MongoClient>();
+
+// Track if we're in a migration context
+let inMigrationContext = false;
+
+/**
+ * Mark the start of a migration
+ * @internal Used by migration runner
+ */
+export const _startMigration = () => {
+  inMigrationContext = true;
+};
+
+/**
+ * Mark the end of a migration and close all connections
+ * @internal Used by migration runner
+ */
+export const _endMigration = async () => {
+  inMigrationContext = false;
+  // Close all active connections
+  const promises = Array.from(activeConnections).map((client) => client.close());
+  activeConnections.clear();
+  await Promise.all(promises);
+};
+
 /**
  * Get database connection
  *
+ * When used in migrations, connections are automatically closed after the migration completes.
+ * For manual usage outside migrations, you must close the connection manually.
+ *
  * @param mongoUrl - MongoDB connection URI
  * @returns Promise with database instance
  *
  * @example
  * ```typescript
+ * // In migrations - connection auto-closes after migration
  * const db = await getDb('mongodb://localhost/mydb');
  * await db.collection('users').updateMany(...);
+ *
+ * // Outside migrations - must close manually
+ * const db = await getDb('mongodb://localhost/mydb');
+ * try {
+ *   await db.collection('users').updateMany(...);
+ * } finally {
+ *   await db.client.close();
+ * }
  * ```
  */
 export const getDb = async (mongoUrl: string): Promise<Db> => {
   const client: MongoClient = await MongoClient.connect(mongoUrl);
+
+  // Track connection for auto-cleanup in migrations
+  if (inMigrationContext) {
+    activeConnections.add(client);
+  }
+
   return client.db();
 };
 

package/src/core/modules/migrate/migration-runner.ts

@@ -106,6 +106,8 @@ export class MigrationRunner {
    * Run all pending migrations (up)
    */
   async up(): Promise<void> {
+    const { _endMigration, _startMigration } = await import('./helpers/migration.helper');
+
     const allMigrations = await this.loadMigrationFiles();
     const state = await this.options.stateStore.loadAsync();
     const completedMigrations = (state.migrations || []).map((m) => m.title);
@@ -121,23 +123,32 @@ export class MigrationRunner {
 
     for (const migration of pendingMigrations) {
       console.log(`Running migration: ${migration.title}`);
-      await migration.up();
-
-      // Update state
-      const newState = await this.options.stateStore.loadAsync();
-      const migrations = newState.migrations || [];
-      migrations.push({
-        timestamp: migration.timestamp,
-        title: migration.title,
-      });
-
-      await this.options.stateStore.saveAsync({
-        lastRun: migration.title,
-        migrations,
-        up: () => {},
-      } as any);
 
-      console.log(`✓ Migration completed: ${migration.title}`);
+      // Mark start of migration for auto-cleanup
+      _startMigration();
+
+      try {
+        await migration.up();
+
+        // Update state
+        const newState = await this.options.stateStore.loadAsync();
+        const migrations = newState.migrations || [];
+        migrations.push({
+          timestamp: migration.timestamp,
+          title: migration.title,
+        });
+
+        await this.options.stateStore.saveAsync({
+          lastRun: migration.title,
+          migrations,
+          up: () => {},
+        } as any);
+
+        console.log(`✓ Migration completed: ${migration.title}`);
+      } finally {
+        // Always close connections, even on error
+        await _endMigration();
+      }
     }
 
     console.log('All migrations completed successfully');
@@ -147,6 +158,8 @@ export class MigrationRunner {
    * Rollback the last migration (down)
    */
   async down(): Promise<void> {
+    const { _endMigration, _startMigration } = await import('./helpers/migration.helper');
+
     const state = await this.options.stateStore.loadAsync();
     const completedMigrations = state.migrations || [];
 
@@ -168,17 +181,26 @@ export class MigrationRunner {
     }
 
     console.log(`Rolling back migration: ${migrationToRollback.title}`);
-    await migrationToRollback.down();
 
-    // Update state
-    const newMigrations = completedMigrations.slice(0, -1);
-    await this.options.stateStore.saveAsync({
-      lastRun: newMigrations.length > 0 ? newMigrations[newMigrations.length - 1].title : undefined,
-      migrations: newMigrations,
-      up: () => {},
-    } as any);
+    // Mark start of migration for auto-cleanup
+    _startMigration();
+
+    try {
+      await migrationToRollback.down();
 
-    console.log(`✓ Migration rolled back: ${migrationToRollback.title}`);
+      // Update state
+      const newMigrations = completedMigrations.slice(0, -1);
+      await this.options.stateStore.saveAsync({
+        lastRun: newMigrations.length > 0 ? newMigrations[newMigrations.length - 1].title : undefined,
+        migrations: newMigrations,
+        up: () => {},
+      } as any);
+
+      console.log(`✓ Migration rolled back: ${migrationToRollback.title}`);
+    } finally {
+      // Always close connections, even on error
+      await _endMigration();
+    }
   }
 
   /**

package/src/index.ts

@@ -37,6 +37,7 @@ export * from './core/common/helpers/graphql.helper';
 export * from './core/common/helpers/gridfs.helper';
 export * from './core/common/helpers/input.helper';
 export * from './core/common/helpers/model.helper';
+export * from './core/common/helpers/register-enum.helper';
 export * from './core/common/helpers/scim.helper';
 export * from './core/common/helpers/service.helper';
 export * from './core/common/helpers/table.helper';