refactor(serve): unite extension loader

- Use same container with core package instead of creating a new one (for external extensions).
- Add two types of extensions: route middleware and formatter.
- Bind Vulcan application to container.
- Using centralized extension loader, remove the old loader in serve package.
- Use new super class for all extensions.

Co-authored-by: kokokuo <v6610688@gmail.com>

Author: oscar60310

packages/serve/src/containers/container.ts

@@ -1,25 +1,35 @@
 import { Container as InversifyContainer } from 'inversify';
 import { Container as CoreContainer } from '@vulcan-sql/core';
-import { routeGeneratorModule } from './modules';
+import {
+  applicationModule,
+  extensionModule,
+  routeGeneratorModule,
+} from './modules';
 import { ServeConfig } from '../models';
 
 export class Container {
-  private inversifyContainer = new InversifyContainer();
+  private inversifyContainer?: InversifyContainer;
+  private coreContainer?: CoreContainer;
 
   public get<T>(type: symbol) {
-    return this.inversifyContainer.get<T>(type);
+    const instance = this.inversifyContainer?.get<T>(type);
+    if (!instance)
+      throw new Error(`Cannot resolve ${type.toString()} in container`);
+    return instance;
   }
 
   public async load(config: ServeConfig) {
-    const coreContainer = new CoreContainer();
-    await coreContainer.load(config);
-    this.inversifyContainer.parent = coreContainer.getInversifyContainer();
+    this.coreContainer = new CoreContainer();
+    await this.coreContainer.load(config);
+    this.inversifyContainer = this.coreContainer.getInversifyContainer();
     this.inversifyContainer.load(routeGeneratorModule());
+    await this.inversifyContainer.loadAsync(extensionModule(config));
+    await this.inversifyContainer.loadAsync(applicationModule());
   }
 
-  public unload() {
-    this.inversifyContainer.parent?.unbindAll();
-    this.inversifyContainer.unbindAll();
+  public async unload() {
+    await this.coreContainer?.unload();
+    await this.inversifyContainer?.unbindAllAsync();
   }
 
   public getInversifyContainer() {

packages/serve/src/containers/modules/application.ts

@@ -0,0 +1,8 @@
+import { VulcanApplication } from '@vulcan-sql/serve';
+import { AsyncContainerModule } from 'inversify';
+import { TYPES } from '../types';
+
+export const applicationModule = () =>
+  new AsyncContainerModule(async (bind) => {
+    bind(TYPES.VulcanApplication).to(VulcanApplication);
+  });

packages/serve/src/containers/modules/extension.ts

@@ -0,0 +1,18 @@
+import { ExtensionLoader } from '@vulcan-sql/core';
+import { AsyncContainerModule } from 'inversify';
+import { ServeConfig } from '../../models/serveConfig';
+import { BuiltInRouteMiddlewares } from '@vulcan-sql/serve/middleware';
+import { BuiltInFormatters } from '@vulcan-sql/serve/response-formatter';
+
+export const extensionModule = (options: ServeConfig) =>
+  new AsyncContainerModule(async (bind) => {
+    const loader = new ExtensionLoader(options);
+    // Internal extension modules
+
+    // route middlewares (single module)
+    loader.loadInternalExtensionModule(BuiltInRouteMiddlewares);
+    // formatter (single module)
+    loader.loadInternalExtensionModule(BuiltInFormatters);
+
+    loader.bindExtensions(bind);
+  });

packages/serve/src/containers/modules/index.ts

@@ -1 +1,3 @@
-export * from './routeGeneratorModule';
+export * from './routeGenerator';
+export * from './extension';
+export * from './application';

packages/serve/src/containers/modules/routeGeneratorModule.ts packages/serve/src/containers/modules/routeGenerator.ts

@@ -17,7 +17,7 @@ export const routeGeneratorModule = () =>
       .to(RequestTransformer)
       .inSingletonScope();
 
-    // Request Transformer
+    // Request Validator
     bind<IRequestValidator>(TYPES.RequestValidator)
       .to(RequestValidator)
       .inSingletonScope();
@@ -27,7 +27,7 @@ export const routeGeneratorModule = () =>
       .to(PaginationTransformer)
       .inSingletonScope();
 
-    // Roue Generator
+    // Route Generator
     bind<RouteGenerator>(TYPES.RouteGenerator)
       .to(RouteGenerator)
       .inSingletonScope();

packages/serve/src/containers/types.ts

@@ -8,4 +8,7 @@ export const TYPES = {
   // Application
   AppConfig: Symbol.for('AppConfig'),
   VulcanApplication: Symbol.for('VulcanApplication'),
+  // Extensions
+  Extension_RouteMiddleware: Symbol.for('Extension_RouteMiddleware'),
+  Extension_Formatter: Symbol.for('Extension_Formatter'),
 };

packages/serve/src/index.ts

@@ -2,5 +2,4 @@ export * from './lib/route';
 export * from './lib/middleware';
 export * from './lib/app';
 export * from './models';
-export * from './models';
 export * from './containers';

packages/serve/src/lib/app.ts

@@ -2,26 +2,33 @@ import { APISchema } from '@vulcan-sql/core';
 import * as Koa from 'koa';
 import * as KoaRouter from 'koa-router';
 import { isEmpty, uniq } from 'lodash';
-import { BaseRouteMiddleware, BuiltInRouteMiddlewares } from './middleware';
 import {
   RestfulRoute,
   BaseRoute,
   APIProviderType,
   GraphQLRoute,
   RouteGenerator,
 } from './route';
-import { AppConfig } from '../models';
-import { importExtensions, loadComponents } from './loader';
+import { inject, injectable, multiInject, optional } from 'inversify';
+import { TYPES } from '../containers';
+import { BaseRouteMiddleware } from '../models';
 
+@injectable()
 export class VulcanApplication {
   private app: Koa;
-  private config: AppConfig;
   private restfulRouter: KoaRouter;
   private graphqlRouter: KoaRouter;
   private generator: RouteGenerator;
-  constructor(config: AppConfig, generator: RouteGenerator) {
-    this.config = config;
+  private routeMiddlewares: BaseRouteMiddleware[];
+
+  constructor(
+    @inject(TYPES.RouteGenerator) generator: RouteGenerator,
+    @multiInject(TYPES.Extension_RouteMiddleware)
+    @optional()
+    routeMiddlewares: BaseRouteMiddleware[] = []
+  ) {
     this.generator = generator;
+    this.routeMiddlewares = routeMiddlewares;
     this.app = new Koa();
     this.restfulRouter = new KoaRouter();
     this.graphqlRouter = new KoaRouter();
@@ -77,17 +84,7 @@ export class VulcanApplication {
 
   /** load built-in and extensions middleware classes for app used */
   public async useMiddleware() {
-    // import extension middleware classes
-    const classesOfExtension = await importExtensions(
-      'middlewares',
-      this.config.extensions
-    );
-    const map = await loadComponents<BaseRouteMiddleware>(
-      [...BuiltInRouteMiddlewares, ...classesOfExtension],
-      this.config
-    );
-    for (const name of Object.keys(map)) {
-      const middleware = map[name];
+    for (const middleware of this.routeMiddlewares) {
       this.app.use(middleware.handle.bind(middleware));
     }
   }

packages/serve/src/lib/loader.ts

@@ -1,17 +1,17 @@
-import { getLogger, ILogger, LoggerOptions } from '@vulcan-sql/core';
-import { BuiltInMiddleware } from '../middleware';
+import {
+  getLogger,
+  LoggerOptions,
+  VulcanInternalExtension,
+} from '@vulcan-sql/core';
+import { BuiltInMiddleware } from '@vulcan-sql/serve/models';
 import { KoaRouterContext, KoaNext } from '@vulcan-sql/serve/route';
-import { AppConfig } from '@vulcan-sql/serve/models';
 
-export class AuditLoggingMiddleware extends BuiltInMiddleware {
-  private logger: ILogger;
-  constructor(config: AppConfig) {
-    super('audit-log', config);
-
-    // read logger options from config, if is undefined will set default value
-    const options = this.getOptions() as LoggerOptions;
-    this.logger = getLogger({ scopeName: 'AUDIT', options });
-  }
+@VulcanInternalExtension('audit-log')
+export class AuditLoggingMiddleware extends BuiltInMiddleware<LoggerOptions> {
+  private logger = getLogger({
+    scopeName: 'AUDIT',
+    options: this.getOptions(),
+  });
 
   public async handle(context: KoaRouterContext, next: KoaNext) {
     if (!this.enabled) return next();

packages/serve/src/lib/middleware/built-in-middleware/auditLogMiddleware.ts packages/serve/src/lib/middleware/auditLogMiddleware.ts

@@ -0,0 +1,16 @@
+import * as cors from '@koa/cors';
+import { KoaRouterContext, KoaNext } from '@vulcan-sql/serve/route';
+import { BuiltInMiddleware } from '@vulcan-sql/serve/models';
+import { VulcanInternalExtension } from '@vulcan-sql/core';
+
+export type CorsOptions = cors.Options;
+
+@VulcanInternalExtension('cors')
+export class CorsMiddleware extends BuiltInMiddleware<CorsOptions> {
+  private koaCors = cors(this.getOptions());
+
+  public async handle(context: KoaRouterContext, next: KoaNext) {
+    if (!this.enabled) return next();
+    return this.koaCors(context, next);
+  }
+}

packages/serve/src/lib/middleware/built-in-middleware/corsMiddleware.ts

@@ -1,3 +1,21 @@
-// export non-default
-export { BaseRouteMiddleware } from './middleware';
-export * from './built-in-middleware';
+export * from './corsMiddleware';
+export * from './requestIdMiddleware';
+export * from './auditLogMiddleware';
+export * from './rateLimitMiddleware';
+export * from './response-format';
+
+import { CorsMiddleware } from './corsMiddleware';
+import { RateLimitMiddleware } from './rateLimitMiddleware';
+import { RequestIdMiddleware } from './requestIdMiddleware';
+import { AuditLoggingMiddleware } from './auditLogMiddleware';
+import { ResponseFormatMiddleware } from './response-format';
+import { ClassType, ExtensionBase } from '@vulcan-sql/core';
+
+// The order is the middleware running order
+export const BuiltInRouteMiddlewares: ClassType<ExtensionBase>[] = [
+  CorsMiddleware,
+  RateLimitMiddleware,
+  RequestIdMiddleware,
+  AuditLoggingMiddleware,
+  ResponseFormatMiddleware,
+];