@chelseaapps/recommender documentation

dependenciesLegend Declarations Module Bootstrap Providers Exportscluster_RecommenderModulecluster_RecommenderModule_providerscluster_RecommenderModule_exportsRecommenderServiceRecommenderServiceRecommenderModuleRecommenderModuleRecommenderModule->RecommenderServiceRecommenderServiceRecommenderServiceRecommenderService->RecommenderModule

import { Module, DynamicModule, Provider, Global, CacheModule } from '@nestjs/common';
import { RecommenderService } from './recommender.service';
import { RECOMMENDER_OPTIONS } from './constants';
import { RecommenderOptions, RecommenderAsyncOptions, RecommenderOptionsFactory } from './interfaces';
import { createRecommenderProviders } from './recommender.providers';
import { createRecommenderImports } from './recommender.imports';

@Global()
@Module({
    providers: [RecommenderService],
    exports: [RecommenderService],
})
export class RecommenderModule {
    /**
     * Registers a configured Recommender Module for import into the current module
     */
    public static register(options: RecommenderOptions): DynamicModule {
        return {
            imports: createRecommenderImports(options),
            module: RecommenderModule,
            global: options.isGlobal ?? true,
            providers: createRecommenderProviders(options),
        };
    }

    /**
     * Registers a configured Recommender Module for import into the current module
     * using dynamic options (factory, etc)
     */
    public static registerAsync(options: RecommenderAsyncOptions): DynamicModule {
        const providers = [...this.createProviders(options)];

        return {
            imports: [
                CacheModule.registerAsync({
                    imports: options.imports || [],
                    useFactory: async (options: RecommenderOptions) => ({
                        host: options.cache.redis.host,
                        port: options.cache.redis.port,
                    }),
                    inject: [RECOMMENDER_OPTIONS],
                    extraProviders: providers,
                }),
            ],
            global: options.isGlobal ?? true,
            module: RecommenderModule,
            providers,
        };
    }

    private static createProviders(options: RecommenderAsyncOptions): Provider[] {
        if (options.useExisting || options.useFactory) {
            return [this.createOptionsProvider(options)];
        }

        return [
            this.createOptionsProvider(options),
            {
                provide: options.useClass,
                useClass: options.useClass,
            },
        ];
    }

    private static createOptionsProvider(options: RecommenderAsyncOptions): Provider {
        if (options.useFactory) {
            return {
                provide: RECOMMENDER_OPTIONS,
                useFactory: options.useFactory,
                inject: options.inject || [],
            };
        }

        // For useExisting...
        return {
            provide: RECOMMENDER_OPTIONS,
            useFactory: async (optionsFactory: RecommenderOptionsFactory) =>
                await optionsFactory.createRecommenderOptions(),
            inject: [options.useExisting || options.useClass],
        };
    }
}