Add Extensions module and DTOs for extension management and validation

Author: tacxou

extensions/.gitignore

@@ -0,0 +1,2 @@
+*
+!.gitignore

src/app.module.ts

@@ -25,6 +25,7 @@ import { EventEmitterModule } from '@nestjs/event-emitter';
 import { ShutdownObserver } from './_common/observers/shutdown.observer';
 import { ScheduleModule } from '@nestjs/schedule';
 import { HttpModule } from '@nestjs/axios';
+import { ExtensionsModule } from './extensions/extensions.module';
 
 @Module({
   imports: [
@@ -133,6 +134,7 @@ import { HttpModule } from '@nestjs/axios';
     ManagementModule.register(),
     SettingsModule.register(),
     MigrationsModule.register(),
+    ExtensionsModule.register(),
   ],
   controllers: [AppController],
   providers: [

src/extensions/_dto/extension.dto.ts

@@ -0,0 +1,49 @@
+import { Type } from 'class-transformer'
+import { IsDefined, IsEnum, IsOptional, IsString, ValidateNested } from 'class-validator'
+
+export class ExtensionSettingsAppServiceMetadataV1 {
+  @IsDefined()
+  @IsString()
+  public target: string
+
+  @IsOptional()
+  @IsString()
+  public mainModule: string = 'ExtensionModule'
+}
+
+export class ExtensionSettingsMetadataV1 {
+  @ValidateNested()
+  @Type(() => ExtensionSettingsAppServiceMetadataV1)
+  public app: ExtensionSettingsAppServiceMetadataV1
+
+  @ValidateNested()
+  @Type(() => ExtensionSettingsAppServiceMetadataV1)
+  public service: ExtensionSettingsAppServiceMetadataV1
+}
+
+export class ExtensionInformationMetadataV1 {
+  @IsString()
+  public name: string
+
+  @IsString()
+  public author: string
+
+  @IsString()
+  public version: string
+}
+
+export class ExtensionFileV1 {
+  @IsDefined()
+  @IsEnum(['1'])
+  public version: string
+
+  @IsDefined()
+  @ValidateNested()
+  @Type(() => ExtensionInformationMetadataV1)
+  public information: ExtensionInformationMetadataV1
+
+  @IsDefined()
+  @ValidateNested()
+  @Type(() => ExtensionSettingsMetadataV1)
+  public settings: ExtensionSettingsMetadataV1
+}

src/extensions/_dto/extensions.dto.ts

@@ -0,0 +1,19 @@
+import { Type } from 'class-transformer'
+import { IsBoolean, IsEnum, IsString, ValidateNested } from 'class-validator'
+
+export class ExtensionsListV1 {
+  @IsString()
+  public path: string
+
+  @IsBoolean()
+  public enabled: boolean
+}
+
+export class ExtensionsFileV1 {
+  @IsEnum(['1'])
+  public version: string
+
+  @ValidateNested({ each: true })
+  @Type(() => ExtensionsListV1)
+  public list: ExtensionsListV1[]
+}

src/extensions/extensions.module.ts

@@ -0,0 +1,30 @@
+import { DynamicModule, Logger, Module, OnModuleInit } from '@nestjs/common'
+import { RouterModule } from '@nestjs/core'
+import serviceSetup from '~/extensions/extensions.service.setup'
+
+@Module({
+  imports: [],
+})
+export class ExtensionsModule implements OnModuleInit {
+  public async onModuleInit(): Promise<void> {
+    Logger.log('All extensions is initialized', 'ExtensionsModule')
+  }
+
+  public static async register(): Promise<DynamicModule> {
+    Logger.debug('Registering extensions', 'ExtensionsModule')
+    const modules = await serviceSetup()
+
+    return {
+      module: this,
+      imports: [
+        ...modules,
+        RouterModule.register([
+          {
+            path: 'extensions',
+            children: [...Reflect.getMetadata('imports', this)],
+          },
+        ]),
+      ],
+    }
+  }
+}

src/extensions/extensions.service.setup.ts

@@ -0,0 +1,80 @@
+import { existsSync, readFileSync } from 'fs'
+import { dirname, join } from 'path'
+import { parse } from 'yaml'
+import { ExtensionFileV1 } from './_dto/extension.dto'
+import { ExtensionsFileV1, ExtensionsListV1 } from './_dto/extensions.dto'
+import { plainToInstance } from 'class-transformer'
+import { validateOrReject } from 'class-validator'
+import * as process from 'process'
+import { DynamicModule, Logger } from '@nestjs/common'
+
+const serviceList: DynamicModule[] = []
+
+export const EXTENSION_FILE_INFO = 'extension.yml'
+export const EXTENSIONS_FILE_PATH = join(process.cwd(), '/extensions/list.yml')
+
+export async function parseExtensionsList(): Promise<ExtensionsListV1[]> {
+  const data = readFileSync(EXTENSIONS_FILE_PATH, 'utf8')
+  const yml = parse(data)
+  const schema = plainToInstance(ExtensionsFileV1, yml)
+  try {
+    await validateOrReject(schema, {
+      whitelist: true,
+    })
+  } catch (errors) {
+    const err = new Error(`Invalid extensions`)
+    err.message = errors.map((e) => e.toString()).join(', ') //TODO: improve error message
+    throw err
+  }
+
+  return yml.list
+}
+
+export async function extensionParseFile(path: string): Promise<ExtensionFileV1> {
+  Logger.log('Extension file found, validating...', 'extensionParseFile')
+  const data = readFileSync(`${path}/${EXTENSION_FILE_INFO}`, 'utf8')
+  const yml = parse(data)
+  return plainToInstance(ExtensionFileV1, yml)
+}
+
+export default async function (): Promise<DynamicModule[]> {
+  try {
+    if (existsSync(EXTENSIONS_FILE_PATH)) {
+      Logger.log('Extensions file found, validating...', 'parsingAppExtensions')
+      const list = await parseExtensionsList()
+
+      for (const extension of list) {
+        if (!extension.enabled) {
+          Logger.log(`Extension ${extension.path} is disabled`, 'ExtensionServiceSetup')
+          continue
+        }
+        const extensionPath = `${process.cwd()}/extensions/${extension.path}`
+        const extensionFile = await extensionParseFile(extensionPath)
+        if (!extensionFile.settings.service.target) {
+          Logger.warn(`Extension ${extensionFile.information.name} has no service target`, 'ExtensionServiceSetup')
+          continue
+        }
+        const extensionServiceTarget = `${extensionPath}/${extensionFile.settings.service.target}`
+        await import(extensionServiceTarget)
+          .then((module) => {
+            if (module[extensionFile.settings.service.mainModule]) {
+              serviceList.push(module[extensionFile.settings.service.mainModule])
+              Logger.log(`Extension ${extensionFile.information.name} is enabled`, 'ExtensionServiceSetup')
+              return
+            }
+            Logger.warn(`Extension <${extensionFile.information.name}> module <${extensionFile.settings.service.mainModule}> has no main module`, 'ExtensionServiceSetup')
+          })
+          .catch((err) => {
+            Logger.error(`Extension <${extensionFile.information.name}> located in <${extensionServiceTarget}> failed to load`, 'ExtensionServiceSetup')
+            console.error(err)
+            console.trace(err.stack)
+          })
+      }
+    }
+    return serviceList
+  } catch (err) {
+    Logger.error('Failed to load extensions', 'ExtensionServiceSetup')
+    console.error(err)
+    process.exit(1)
+  }
+}