> = (context: interfaces.Context) => (app?: express.Application) => {
if (!app) {
app = express();
}
context.container.get<interfaces.Factory<express.Application>>(
registry.ExpressConfig
)(app);
useContainer(context.container);
useExpressServer(app, {
routePrefix: '/api',
controllers: [
CardSetController
],
development: false,
validation: { validationError: { target: false, value: false } }
});
// Setup express to serve static files
app.use(express.static(path.resolve(__dirname, 'client', 'assets')));
app.use(express.static(path.resolve(__dirname, 'client')));
// Catch all route to support Angular 2 pushstate routing
app.get('*', (_req: express.Request, res: express.Response): void => {
res.sendFile(path.resolve(__dirname, 'client', 'index.html'));
});
context.container.get<interfaces.Factory<express.Application>>(
registry.ExpressErrorConfig
)(app);
return app;
};
> = (context: interfaces.Context) => (app?: express.Application) => {
if (!app) {
app = express();
}
context.container.get<interfaces.Factory<express.Application>>(
registry.ExpressConfig
)(app);
useContainer(context.container);
useExpressServer(app, {
routePrefix: '/api',
controllers: [
CardSetController
],
development: true,
validation: { validationError: { target: false, value: false } }
});
app.use(historyApiFallback());
app.use(
webpackMiddleware(webpack(webpackDevConfig), {
publicPath: '/',
index: 'index.html',
stats: {
colors: true
}
})
);
context.container.get<interfaces.Factory<express.Application>>(
registry.ExpressErrorConfig
)(app);
return app;
};
beforeEach(async () => {
container = new Container();
container.load(ormModule);
// Services
container
.bind<SettingsServiceAttributes>(registry.SettingsService)
.to(MockSettingsService)
.inSingletonScope();
mockSettingsService = container.get<SettingsServiceAttributes>(
registry.SettingsService
);
mockSettingsService.loggerTransports = [
new winston.transports.Console({
silent: true
})
];
mockLogger = new winston.Logger();
const loggerFactory: interfaces.FactoryCreator<winston.LoggerInstance> = (
context: interfaces.Context
) => {
return () => {
return mockLogger;
};
};
container
.bind<interfaces.Factory<winston.LoggerInstance>>(registry.LoggerFactory)
.toFactory(loggerFactory);
// ORM
container
.bind<ConnectionOptions>(registry.ORMConnectionOptions)
.toConstantValue({
autoSchemaSync: true,
type: 'sqlite',
database: ':memory:'
});
connection = (await container.get<interfaces.Provider<Connection>>(
registry.ORMConnectionProvider
)()) as Connection;
// Express configs
container
.bind<CardSetControllerAttributes>(CardSetController)
.toSelf();
app = express();
useContainer(container);
useExpressServer(app, {
routePrefix: '/api',
controllers: [CardSetController],
development: true
});
});
> = (context: interfaces.Context) => (app?: express.Application) => {
if (!app) {
app = express();
}
context.container.get<interfaces.Factory<express.Application>>(
registry.ExpressConfig
)(app);
useContainer(context.container);
useExpressServer(app, {
routePrefix: '/api',
controllers: [
CardSetController
],
development: false,
validation: { validationError: { target: false, value: false } }
});
context.container.get<interfaces.Factory<express.Application>>(
registry.ExpressErrorConfig
)(app);
return app;
};
import "reflect-metadata";
import {useContainer, useExpressServer} from "routing-controllers";
import {Container} from "typedi";
// setup routing-controllers to use typedi container. You can use any container here
useContainer(Container);
// create and setup our own express app
const express = require("express");
const cors = require("cors");
const expressApp = express();
expressApp.use(cors());
// create express server
useExpressServer(expressApp, { // alternatively you can use useExpressServer with your own preconfigured express server
controllerDirs: [__dirname + "/controllers/**/*.js"]
});
// run express app
expressApp.listen(4000);
console.log("API is up and running at port 4000");
middlewares: env.app.dirs.middlewares,
});
winston.configure({
transports: [
new winston.transports.Console({
level: env.log.level,
handleExceptions: true,
json: env.log.json,
timestamp: env.node !== "development",
colorize: env.node === "development",
}),
],
});
routingUseContainer(Container);
ormUseContainer(Container);
classValidatorUseContainer(Container);
// Register validator schemes
env.app.dirs.validatorSchemes.forEach((pattern) => {
glob(pattern, (err: any, files: Array<string>) => {
for (const file of files) {
const schemas = require(file);
Object.keys(schemas).forEach((key) => {
registerSchema(schemas[key]);
});
}
});
});
export const bootstrapApp = async (): Promise<BootstrapSettings> => {
/**
* We create a new express server instance.
*/
const app: express.Application = express();
app.use(json({ limit: "50mb" }));
app.use(urlencoded({ extended: true }));
useExpressServer(app, {
cors: true,
routePrefix: env.app.routePrefix,
defaultErrorHandler: false,
classTransformer: true,
validation: true,
/**
* We can add options about how routing-controllers should configure itself.
* Here we specify what controllers should be registered in our express server.
*/
controllers: env.app.dirs.controllers,
middlewares: env.app.dirs.middlewares,
});
winston.configure({
transports: [
new winston.transports.Console({
level: env.log.level,
handleExceptions: true,
json: env.log.json,
timestamp: env.node !== "development",
colorize: env.node === "development",
}),
],
});
routingUseContainer(Container);
ormUseContainer(Container);
classValidatorUseContainer(Container);
// Register validator schemes
env.app.dirs.validatorSchemes.forEach((pattern) => {
glob(pattern, (err: any, files: Array<string>) => {
for (const file of files) {
const schemas = require(file);
Object.keys(schemas).forEach((key) => {
registerSchema(schemas[key]);
});
}
});
});
env.app.dirs.subscribers.forEach((pattern) => {
glob(pattern, (err: any, files: Array<string>) => {
for (const file of files) {
require(file);
}
});
});
const initTypeORM = async () => {
const loadedConnectionOptions = await getConnectionOptions();
const connectionOptions = Object.assign(loadedConnectionOptions, {
type: env.db.type as any, // See createConnection options for valid types
host: env.db.host,
port: env.db.port,
username: env.db.username,
password: env.db.password,
database: env.db.database,
synchronize: env.db.synchronize,
logging: env.db.logging,
entities: env.app.dirs.entities,
migrations: env.app.dirs.migrations,
});
return createConnection(connectionOptions);
};
app.get(
env.app.routePrefix,
(req: express.Request, res: express.Response) => {
return res.json({
name: env.app.name,
version: env.app.version,
description: env.app.description,
});
},
);
const log = new Logger(__filename);
try {
const connection = await initTypeORM();
const server: http.Server = app.listen(env.app.port);
banner(log);
return {
app,
server,
connection,
} as BootstrapSettings;
} catch (error) {
log.error(`Application is crashed: ${error}`);
throw error;
}
};