TypeScript Application.use方法代码示例

    public static MakeRoutes(express: Application): void {
        const keys = Object.keys(routes);
        Server.Log('Registering routes: ', keys);

        for (let key in keys) {
            key = keys[key];
            if (!routes.hasOwnProperty(key)) {
                continue;
            }

            let route = routes[key];
            let split = key.split(' ');

            if (split[0] === 'post') {
                express.post(split[1], route);
            } else {
                express.get(split.length === 1 ? split[0] : split[1], route);
            }
        }

        express.use(function(req: Request, res: Response) {
            res.status(404).render('errors/404.html', { title: '404: File Not Found' });
        });

        express.use(function(error: Error, req: Request, res: Response, next: any) {
            res.status(500).render('errors/500.html', { title: '500: Internal Server Error', error: error });
        });
    }

 middleware(): void {
     this.express.use(morgan('dev'));
     this.express.use(bodyParser.urlencoded({ extended: true }));
     this.express.use(bodyParser.json());
     this.express.use(Handlers.errorHandlerApi);
     this.express.use(Auth.config().initialize());
     this.router(this.express,  Auth);
 }

/**
 * Applies limits config to app
 */
export default function applyLimitsToApp(app: Application, config: AppConfig) {
  if (config.trustProxy) {
    app.enable('trust proxy');
  }

  app.use('/api/', new RateLimit(applyLimits(config.api.options.limits)));
  app.use('/peer/', new RateLimit(applyLimits(config.peers.options.limits)));

}

export default (app: Application, config: Config) => {
    app.use(buster());
    let staticOptions = {};
    if (process.env.NODE_ENV === 'production') {
        staticOptions = { maxAge: '30d' };
    }
    app.use(express.static(
        path.join(__dirname, '..', '..', '..', 'public'),
        staticOptions));
    app.use(cookies(config));
    app.use(session());
};

export function startStaticServer(host: string, port: number, basePath: string, topologyOverrides: Topology, options: StaticServerOptions = defaultServerOptions): Promise<Server> {
    const app: Application = express();
    if(options.debug) {
        app.use(log());
    }
    app.use(basePath, bundlessExpress(topologyOverrides));
    return new Promise<Server>((resolve, reject) => {
        app.listen(port, host, function (err) {
            if(err) {
                reject(err);
            } else {
                resolve(this);
            }
        })
    });
}

function startExpress(port : number) : Promise<void> {

    app = express();
    app.use(bodyParser.json());

    return new Promise<void>(function(resolve, reject) {
        server = app.listen(port, () =>  resolve());
    });
}

/**
 * Configure logger
 * @param  {string} logfile Path to logfile
 * @param  {object} config Configuration for transports
 * @return {winston.Logger}
 */
export default function(app: Application, options: ILoggingOptions) {
  const cwd = process.cwd();
  const logFile = path.resolve(cwd, `${options.dir}/${options.file}`);
  const addRequestId = require("express-request-id")({ setHeader: false });

  app.use(addRequestId);
  morgan.token("id", (req: IRequestWithId) => req.id.split("-")[0]);

  app.use(morgan("[:date[iso] #:id] Started :method :url for :remote-addr", {immediate: true}));

  app.use(morgan("[: date[iso] #: id] Completed : status : res[content - length] in : response - time ms"));

  // If logs directory does not exist, create one
  if (!fs.existsSync(path.resolve(cwd, options.dir))) {
    mkdirp.sync(path.resolve(cwd, options.dir));
  }

  // If log file does not exist, create one with empty content.
  if (!fs.existsSync(logFile)) {
    fs.writeFileSync(logFile, "");
  }

  const logger = winston.createLogger({
    exitOnError: false,
    format: winston.format.json(),
    level: "info",
    transports: [
      new winston.transports.File({
        filename: logFile,
        handleExceptions: true,
        level: "info",
        maxFiles: 5,
        maxsize: 5242880, // 5MB
      }),
      new winston.transports.Console({
        handleExceptions: true,
        level: "debug",
      }),
    ],

  });

  return logger;
}

    constructor(public app: Application, public router: Router) {
        new AuthRoutes(app);
        new CategoryRoutes(router);
        new GameRoutes(router);

        const unprotected = ['/api/alive', '/api/games-create', '/api/games-join'];
        app.use('/api/', expressJwt({ secret }).unless({ path: unprotected }), router);

        app.get('/report/', (req, res) => {
            r.table('players').count().then(count => {
                res.json(count);
            })
        });
    }

export default function(cthulhu: Application, secret: string) {
  if (secret === void 0) { throw Error("Must provide `secret` in configuration"); }

  cthulhu.use(session({
    genid(req) {
      return uuid.v4();
    },
    // Do not save session if nothing has been modified
    resave: false,
    // Do not create session unless something is to be stored
    saveUninitialized: false,
    secret,
  }));
}

function setupCommonRoute(app: Application){
	app.get('/boards', function(req:Request, res:Response){
		tokenGuard(req).then(function(token:string){
			res.render("boards");
		})
		.catch( function(error:string){
			env().logger().error(error);
			//res.render("index");
			 res.redirect('/');
		})
	});  
	
	app.get('/', function(req, res){
		res.render("index");
	});

	app.use((req, res, next) => {
		var err = new Error('Not Found');
		err['status'] = 404;
		next(err);
	});
}