add config module

src/modules/content/config.ts

@@ -0,0 +1,12 @@
+import { ConfigureFactory, ConfigureRegister } from '../config/types';
+
+import { ContentConfig } from './types';
+
+export const defauleContentConfig: ContentConfig = { searchType: 'mysql', htmlEnabled: false };
+
+export const createContentConfig: (
+    register: ConfigureRegister<RePartial<ContentConfig>>,
+) => ConfigureFactory<ContentConfig> = (register) => ({
+    register,
+    defaultRegister: () => defauleContentConfig,
+});

src/modules/content/content.module.ts

@@ -11,19 +11,19 @@ import { SanitizeService } from '@/modules/content/services/SanitizeService';
 
 import { PostService } from '@/modules/content/services/post.service';
 import { PostSubscriber } from '@/modules/content/subscribers/post.subscriber';
-import { ContentConfig } from '@/modules/content/types';
 import { DatabaseModule } from '@/modules/database/database.module';
 
+import { Configure } from '../config/configure';
+
+import { defauleContentConfig } from './config';
+import { ContentConfig } from './types';
+
 @Module({})
 export class ContentModule {
-    static forRoot(configRegister?: () => ContentConfig): DynamicModule {
-        const config: Required<ContentConfig> = {
-            SearchType: 'mysql',
-            ...(configRegister ? configRegister() : {}),
-        };
+    static async forRoot(configure: Configure): Promise<DynamicModule> {
+        const config = await configure.get<ContentConfig>('content', defauleContentConfig);
         const providers: ModuleMetadata['providers'] = [
             ...Object.values(services),
-            SanitizeService,
             PostSubscriber,
             {
                 provide: PostService,
@@ -47,13 +47,23 @@ export class ContentModule {
                         categoryService,
                         tagRepository,
                         searchService,
-                        config.SearchType,
+                        config.searchType,
                     );
                 },
             },
         ];
-        if (config.SearchType === 'meili') {
+        const exports: ModuleMetadata['exports'] = [
+            ...Object.values(services),
+            PostService,
+            DatabaseModule.forRepository(Object.values(repositories)),
+        ];
+        if (config.searchType === 'meili') {
             providers.push(services.SearchService);
+            exports.push(SearchService);
+        }
+        if (config.htmlEnabled) {
+            providers.push(SanitizeService);
+            exports.push(SanitizeService);
         }
         return {
             module: ContentModule,
@@ -63,11 +73,7 @@ export class ContentModule {
             ],
             controllers: Object.values(controllers),
             providers,
-            exports: [
-                ...Object.values(services),
-                PostService,
-                DatabaseModule.forRepository(Object.values(repositories)),
-            ],
+            exports,
         };
     }
 }

src/modules/content/subscribers/post.subscriber.ts

@@ -1,5 +1,8 @@
+import { Optional } from '@nestjs/common';
+import { isNil } from 'lodash';
 import { DataSource, EventSubscriber, ObjectType } from 'typeorm';
 
+import { Configure } from '@/modules/config/configure';
 import { PostBodyType } from '@/modules/content/constants';
 import { PostEntity } from '@/modules/content/entities/post.entity';
 import { PostRepository } from '@/modules/content/repositories/post.repository';
@@ -11,14 +14,19 @@ export class PostSubscriber extends BaseSubscriber<PostEntity> {
     protected entity: ObjectType<PostEntity> = PostEntity;
     constructor(
         protected dataSource: DataSource,
-        protected sanitizeService: SanitizeService,
         protected postRepository: PostRepository,
+        protected configure: Configure,
+        @Optional() protected sanitizeService: SanitizeService,
     ) {
         super(dataSource);
     }
 
     async afterLoad(entity: PostEntity) {
-        if (entity.type === PostBodyType.HTML) {
+        if (
+            (await this.configure.get('content.htmlEnabled')) &&
+            !isNil(this.sanitizeService) &&
+            entity.type === PostBodyType.HTML
+        ) {
             entity.body = this.sanitizeService.sanitize(entity.body);
         }
     }

src/modules/content/types.ts

@@ -3,7 +3,8 @@ import { SelectTrashMode } from '@/modules/database/constants';
 export type SearchType = 'mysql' | 'meili';
 
 export interface ContentConfig {
-    SearchType?: SearchType;
+    searchType: SearchType;
+    htmlEnabled: boolean;
 }
 
 export interface SearchOption {