@mvx/mvc
Version:
@mvx/mvc is mvc framework on server, base on koa, @tsdi frameworks
287 lines (285 loc) • 12.5 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.MvcStartupService = exports.MvcApplication = void 0;
const tslib_1 = require("tslib");
const ioc_1 = require("@tsdi/ioc");
const core_1 = require("@tsdi/core");
const aop_1 = require("@tsdi/aop");
const logs_1 = require("@tsdi/logs");
const boot_1 = require("@tsdi/boot");
const platform_server_boot_1 = require("@tsdi/platform-server-boot");
const platform_server_logs_1 = require("@tsdi/platform-server-logs");
const decorators_1 = require("./decorators");
const MvcContext_1 = require("./MvcContext");
const ControllerRegisterAction_1 = require("./registers/ControllerRegisterAction");
const MiddlewareRegisterAction_1 = require("./registers/MiddlewareRegisterAction");
const MvcServer_1 = require("./MvcServer");
const DefaultMvcMiddlewares_1 = require("./DefaultMvcMiddlewares");
const http = require("http");
const https = require("https");
const MvcApp_1 = require("./MvcApp");
const RouteChecker_1 = require("./services/RouteChecker");
const AuthorizationAspect_1 = require("./aop/AuthorizationAspect");
const MvcMiddleware_1 = require("./middlewares/MvcMiddleware");
const ControllerRoute_1 = require("./router/ControllerRoute");
const CorsMiddleware_1 = require("./router/CorsMiddleware");
const Router_1 = require("./router/Router");
const MvcMiddlewares_1 = require("./middlewares/MvcMiddlewares");
const MiddlewareRegister_1 = require("./middlewares/MiddlewareRegister");
const RouterMiddleware_1 = require("./router/RouterMiddleware");
const BeforeMidddlewareStartupService_1 = require("./services/BeforeMidddlewareStartupService");
const AfterMidddlewareStartupService_1 = require("./services/AfterMidddlewareStartupService");
const ServerFactory_1 = require("./ServerFactory");
const mount = require('koa-mount');
/**
* Default Application of type mvc.
*
* @export
* @class Application
* @implements {IApplication}
*/
class MvcApplication extends boot_1.BootApplication {
getBootDeps() {
let deps = super.getBootDeps();
return [aop_1.AopModule, logs_1.LogModule, platform_server_boot_1.ServerBootstrapModule, boot_1.ORMCoreModule, platform_server_logs_1.ServerLogsModule, MvcCoreModule, MvcStartupService, ...deps];
}
/**
* run mvc application.
*
* @static
* @template T
* @param {(T | Type | MvcOptions)} [target]
* @param {(LoadType[] | LoadType | string)} [deps]
* @param {...string[]} args
* @returns {Promise<T>}
* @memberof MvcApplication
*/
static async run(target, deps, ...args) {
let mdargs = boot_1.checkBootArgs(deps, ...args);
target = target || MvcApp_1.MvcApp;
return await new MvcApplication(target, mdargs.deps).run(...mdargs.args);
}
onContextInit(ctx) {
super.onContextInit(ctx);
this.getContainer().setValue(MvcContext_1.MvcContextToken, ctx);
}
static ρAnn() {
return { "name": "MvcApplication" };
}
}
exports.MvcApplication = MvcApplication;
/**
* configure register.
*
* @export
* @class MvcConfigureRegister
* @extends {ConfigureRegister}
*/
let MvcStartupService = class MvcStartupService extends boot_1.StartupService {
async configureService(ctx) {
// befor process exit.
if (ioc_1.isDefined(process)) {
process.once('beforeExit', () => {
ctx.destroy();
});
}
this.ctx = ctx;
this.logger = ctx.getLogManager().getLogger();
this.logger.info('startup mvc controllers and middlewares');
const config = ctx.getConfiguration();
this.subs = [];
ctx.getKoa().keys = config.keys;
let injector = ctx.injector;
let logConfig = config.logConfig;
if (logConfig && !injector.has(logs_1.LogConfigureToken)) {
injector.bindProvider(logs_1.LogConfigureToken, logConfig);
}
if (!injector.has(DefaultMvcMiddlewares_1.DefaultMvcMiddlewaresToken)) {
injector.bindProvider(DefaultMvcMiddlewares_1.DefaultMvcMiddlewaresToken, DefaultMvcMiddlewares_1.DefaultMvcMiddlewares);
}
// setup global middlewares
let middlewares = injector.get(MvcMiddlewares_1.MvcMiddlewares);
let metadata = ctx.getAnnoation();
let mvcMiddles = metadata.middlewares || injector.get(DefaultMvcMiddlewares_1.DefaultMvcMiddlewaresToken);
if (ioc_1.isArray(mvcMiddles)) {
mvcMiddles.forEach(middle => {
if (ioc_1.isClass(middle)) {
middlewares.use(middle);
}
else if (ioc_1.isFunction(middle)) {
let mid = middle(config, ctx);
if (ioc_1.isFunction(mid)) {
middlewares.use(mid);
}
}
else if (middle instanceof boot_1.Handle) {
middlewares.use(middle);
}
});
}
// load extends midllewares.
if (config.loadMiddlewares) {
await injector.load({
basePath: ctx.getRootPath(),
files: config.loadMiddlewares
});
}
injector.invoke(MiddlewareRegister_1.MiddlewareRegister, tag => tag.setup);
if (!injector.hasRegister(ServerFactory_1.ServerFactoryToken)) {
injector.setValue(ServerFactory_1.ServerFactoryToken, (ctx, config) => {
return config.httpsOptions ?
(config.httpsOptions.secureProtocol ?
https.createServer(config.httpsOptions, ctx.getKoa().callback())
: http.createServer(config.httpsOptions, ctx.getKoa().callback()))
: http.createServer(ctx.getKoa().callback());
});
}
if (!ctx.httpServer) {
ctx.httpServer = injector.get(ServerFactory_1.ServerFactoryToken)(ctx, config);
}
if (config.loadControllers) {
await injector.load({
basePath: ctx.getRootPath(),
files: config.loadControllers
});
}
await Promise.all(injector.getServices(BeforeMidddlewareStartupService_1.BeforeMidddlewareStartupService)
.map(s => s.startup(ctx, middlewares)));
injector.get(MvcMiddlewares_1.MvcMiddlewares)
.setup(ctx);
await Promise.all(injector.getServices(AfterMidddlewareStartupService_1.AfterMidddlewareStartupService)
.map(s => s.startup(ctx, middlewares)));
if (config.subSites && config.subSites.length) {
await Promise.all(config.subSites.map(async (site) => {
let koa;
let subCtx;
if (ioc_1.isClass(site.app)) {
let subCtx = await MvcApplication.run({
autorun: false,
module: site.app,
configures: [ioc_1.lang.omit(config, 'subsites')]
});
this.subs.push(subCtx);
koa = subCtx.getKoa();
}
else if (ioc_1.isFunction(site.app)) {
koa = await site.app(config);
}
else {
koa = site.app;
}
if (koa) {
ctx.getKoa().use(mount(site.routePrefix, koa));
}
}));
}
}
destroying() {
this.logger.info('remove controllers and middlewares.');
let koa = this.ctx.getKoa();
koa.removeAllListeners();
koa.middleware.length = 0;
if (this.subs.length) {
this.subs.forEach(s => s === null || s === void 0 ? void 0 : s.destroy());
}
}
static ρAnn() {
return { "name": "MvcStartupService", "params": { "configureService": ["ctx"] } };
}
};
MvcStartupService = tslib_1.__decorate([
boot_1.Boot({
before: 'all'
})
], MvcStartupService);
exports.MvcStartupService = MvcStartupService;
let MvcCoreModule = class MvcCoreModule {
constructor() {
}
setup(container) {
container.registerType(MvcContext_1.MvcContext)
.registerType(MvcServer_1.MvcServer);
container.inject(AuthorizationAspect_1.AuthorizationAspect, RouteChecker_1.RouteChecker, MvcMiddleware_1.CompositeMiddleware, MvcMiddlewares_1.MvcMiddlewares, MiddlewareRegister_1.MiddlewareRegister, CorsMiddleware_1.CorsMiddleware, Router_1.Router, ControllerRoute_1.ControllerRoute, RouterMiddleware_1.RouterMiddleware);
container.bindProvider(boot_1.DefaultConfigureToken, {
hostname: '',
port: 3000,
routePrefix: '',
setting: {},
loadMiddlewares: ['./middlewares/**/*{.js,.ts}', '!./**/*.d.ts'],
loadControllers: ['./controllers/**/*{.js,.ts}', '!./**/*.d.ts'],
aop: ['./aop/**/*{.js,.ts}', '!./**/*.d.ts'],
views: './views',
corsOptions: {
allowMethods: 'GET,PUT,POST,DELETE,OPTIONS',
keepHeadersOnError: true,
maxAge: 60 * 60 * 1000
},
viewsOptions: {
extension: 'ejs',
map: { html: 'nunjucks' }
},
models: ['./models/**/*{.js,.ts}', '!./**/*.d.ts'],
repositories: ['./repositories/**/*.(ts|js)', '!./**/*.d.ts'],
keys: ['typemvc'],
contents: ['./public']
});
let actInjector = container.getInstance(ioc_1.ActionInjector);
actInjector.register(ControllerRegisterAction_1.ControllerRegisterAction)
.register(MiddlewareRegisterAction_1.MiddlewareRegisterAction);
let dreger = actInjector.getInstance(ioc_1.DesignRegisterer);
dreger.register(decorators_1.Controller, 'Class', ioc_1.TypeProviderAction, ControllerRegisterAction_1.ControllerRegisterAction)
.register(decorators_1.Authorization, 'Class', ioc_1.TypeProviderAction)
.register(decorators_1.Middleware, 'Class', ioc_1.TypeProviderAction, MiddlewareRegisterAction_1.MiddlewareRegisterAction);
boot_1.registerModule(decorators_1.MvcModule, dreger);
let runtimeRgr = actInjector.getInstance(ioc_1.RuntimeRegisterer);
runtimeRgr.register(decorators_1.Authorization, 'Method', ioc_1.MthProviderAction)
.register(decorators_1.MvcModule, 'Class', ioc_1.IocSetCacheAction);
actInjector.getInstance(ioc_1.DecoratorProvider)
.bindProviders(decorators_1.MvcModule, {
provide: boot_1.ModuleProvidersBuilderToken,
useValue: {
build(providers, annoation) {
if (annoation.controllers && annoation.controllers.length) {
providers.injectModule(...annoation.controllers);
}
}
}
}, {
provide: boot_1.BootContext,
deps: [core_1.ContainerToken],
useFactory: (container, ...providers) => {
let ref = new ioc_1.InjectReference(boot_1.BootContext, decorators_1.MvcModule.toString());
if (container.has(ref)) {
return container.get(ref, ...providers);
}
else {
return container.get(MvcContext_1.MvcContext, ...providers);
}
}
}, {
provide: boot_1.Startup,
deps: [core_1.ContainerToken],
useFactory: (container, ...providers) => {
let ref = new ioc_1.InjectReference(boot_1.Startup, decorators_1.MvcModule.toString());
if (container.has(ref)) {
return container.get(ref, ...providers);
}
return null;
}
});
}
static ρAnn() {
return { "name": "MvcCoreModule", "params": { "setup": ["container"] } };
}
};
tslib_1.__decorate([
tslib_1.__param(0, ioc_1.Inject(core_1.ContainerToken)),
tslib_1.__metadata("design:type", Function),
tslib_1.__metadata("design:paramtypes", [Object]),
tslib_1.__metadata("design:returntype", void 0)
], MvcCoreModule.prototype, "setup", null);
MvcCoreModule = tslib_1.__decorate([
ioc_1.IocExt(),
tslib_1.__metadata("design:paramtypes", [])
], MvcCoreModule);
//# sourceMappingURL=sourcemaps/MvcApplication.js.map