Module Configuration

class MongooseModule {
  /**
   * Configure the root MongoDB connection
   * @param uri - MongoDB connection string
   * @param options - Connection options
   * @returns DynamicModule for root configuration
   */
  static forRoot(uri: string, options?: MongooseModuleOptions): DynamicModule;

  /**
   * Configure the root MongoDB connection asynchronously
   * @param options - Async configuration options
   * @returns DynamicModule for async root configuration
   */
  static forRootAsync(options: MongooseModuleAsyncOptions): DynamicModule;

  /**
   * Register models for dependency injection
   * @param models - Array of model definitions (defaults to empty array)
   * @param connectionName - Optional connection name for multi-database setup
   * @returns DynamicModule for feature registration
   */
  static forFeature(models?: ModelDefinition[], connectionName?: string): DynamicModule;

  /**
   * Register models asynchronously for dependency injection
   * @param factories - Array of async model factories (defaults to empty array)
   * @param connectionName - Optional connection name for multi-database setup
   * @returns DynamicModule for async feature registration
   */
  static forFeatureAsync(factories?: AsyncModelFactory[], connectionName?: string): DynamicModule;
}

// Basic connection
@Module({
  imports: [
    MongooseModule.forRoot('mongodb://localhost/nest'),
  ],
})
export class AppModule {}

// Connection with options
@Module({
  imports: [
    MongooseModule.forRoot('mongodb://localhost/nest', {
      retryAttempts: 5,
      retryDelay: 1000,
      connectionName: 'users-db',
    }),
  ],
})
export class AppModule {}

// Async configuration with ConfigService
@Module({
  imports: [
    MongooseModule.forRootAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        uri: configService.get<string>('MONGODB_URI'),
        retryAttempts: 5,
      }),
      inject: [ConfigService],
    }),
  ],
})
export class AppModule {}

// Register models
@Module({
  imports: [
    MongooseModule.forFeature([
      { name: User.name, schema: UserSchema },
      { name: Product.name, schema: ProductSchema, collection: 'products' }
    ]),
  ],
})
export class UsersModule {}

interface MongooseModuleOptions extends ConnectOptions {
  /** MongoDB connection URI */
  uri?: string;
  /** Number of retry attempts for failed connections */
  retryAttempts?: number;
  /** Delay between retry attempts in milliseconds */
  retryDelay?: number;
  /** Name for this connection (for multiple databases) */
  connectionName?: string;
  /** Factory function to customize the connection */
  connectionFactory?: (connection: any, name: string) => any;
  /** Factory function to customize connection errors */
  connectionErrorFactory?: (error: MongooseError) => MongooseError;
  /** Whether to defer connection until first use */
  lazyConnection?: boolean;
  /** Callback when connection is created */
  onConnectionCreate?: (connection: Connection) => void;
  /** Enable verbose retry logging */
  verboseRetryLog?: boolean;
}

interface MongooseModuleAsyncOptions {
  /** Name for this connection (for multiple databases) */
  connectionName?: string;
  /** Modules to import for dependencies */
  imports?: any[];
  /** Use existing options factory */
  useExisting?: Type<MongooseOptionsFactory>;
  /** Use class as options factory */
  useClass?: Type<MongooseOptionsFactory>;
  /** Factory function to create options */
  useFactory?: (...args: any[]) => Promise<MongooseModuleFactoryOptions> | MongooseModuleFactoryOptions;
  /** Dependencies to inject into factory function */
  inject?: any[];
}

interface MongooseOptionsFactory {
  /**
   * Create Mongoose module options
   * @returns Options object or promise of options
   */
  createMongooseOptions(): Promise<MongooseModuleOptions> | MongooseModuleOptions;
}

type MongooseModuleFactoryOptions = Omit<MongooseModuleOptions, 'connectionName'>;

interface ModelDefinition {
  /** Model name for dependency injection */
  name: string;
  /** Mongoose schema for the model */
  schema: any;
  /** Optional collection name override */
  collection?: string;
  /** Optional discriminator schemas */
  discriminators?: DiscriminatorOptions[];
}

interface AsyncModelFactory {
  /** Model name for dependency injection */
  name: string;
  /** Optional collection name override */
  collection?: string;
  /** Optional discriminator schemas */
  discriminators?: DiscriminatorOptions[];
  /** Modules to import for dependencies */
  imports?: any[];
  /** Factory function to create schema */
  useFactory: (...args: any[]) => ModelDefinition['schema'] | Promise<ModelDefinition['schema']>;
  /** Dependencies to inject into factory function */
  inject?: any[];
}

interface DiscriminatorOptions {
  /** Discriminator name */
  name: string;
  /** Discriminator schema */
  schema: Schema;
  /** Optional discriminator value */
  value?: string;
}