TypeScript compression类代码示例

export default function(config: IAppConfig): IServer {
	let app = express();

	// Make the public folder available
	app.use(express.static(path.resolve(__dirname, '..', 'public')));
	app.use('/shared', express.static(path.resolve(__dirname, '..', 'shared')));

	if (process.env.NODE_ENV === 'local' || process.env.NODE_ENV === 'local-development') {
		// console.log(path.resolve(__dirname, '..', '..', 'src'));
		app.use('/src', express.static(path.resolve(__dirname, '..', '..', 'src')));
		// Make all client files available for dev
		app.use('/node_modules', express.static('node_modules'));
	}

	// Request body parsing middleware should be above methodOverride
	// app.use(bodyParser.urlencoded({
	// 	extended: true
	// }));
	app.use(timeout('30s'));
	// app.use(bodyParser.json());
	// app.use(cookieParser());
	app.use(compression());

	const server = app.listen(config.port, () => {
		console.log("Listening on port", config.port);
	});

	return { express: app, http: server };
}

    newInstance(config: IConfig, env: string): express.Express {
        var app = express();

        app.set("views", config.root + "/server/views");
        app.set("view engine", "html");
        app.use(compression());
        app.use(bodyParser.urlencoded({ extended: false }));
        app.use(bodyParser.json());
        app.use(methodOverride());
        app.use(cookieParser());

        // Persist sessions with mongoStore / sequelizeStore
        // We need to enable sessions for passport-twitter because it"s an
        // oauth 1.0 strategy, and Lusca depends on sessions
        /*app.use(session({
            secret: config.secrets.session,
            saveUninitialized: true,
            resave: false,
            store: new mongoStore({
                mongooseConnection: mongoose.connection,
                db: "opcrates-bot-server"
            })
        }));*/

        app.set("appPath", path.join(config.root, "client"));
        app.use(morgan("dev"));
        app.use(express.static(app.get("appPath")));

        if ("development" === env || "test" === env) {
            app.use(express.static(path.join(config.root, ".tmp")));
            app.use(errorHandler()); // Error handler - has to be last
        }

        return app;
    }

export default function(app) {
  let env = app.get('env');

  app.set('views', config.root + '/server/views');
  app.set('view engine', 'jade');
  app.use(compression());
  app.use(bodyParser.urlencoded({ extended: false }));
  app.use(bodyParser.json());
  app.use(methodOverride());
  app.use(cookieParser());
  app.use(passport.initialize());

  app.set('appPath', path.join(config.root, 'client'));

  if ('production' === env) {
    app.use(favicon(path.join(config.root, 'client', 'favicon.ico')));
    app.use(express.static(app.get('appPath')));
    app.use(morgan('dev'));
  }

  if ('development' === env) {
    app.use(require('connect-livereload')());
  }

  if ('development' === env || 'test' === env) {
    app.use(express.static(path.join(config.root, '.tmp')));
    app.use(express.static(app.get('appPath')));
    app.use(morgan('dev'));
    app.use(errorHandler()); // Error handler - has to be last
  }
}

    @InitPhase
    @Inject(['logger', 'express'])
    load(logger, app) {
        logger.debug('load compression');

        app.use(compression());
    }

  /**
   * Configures application
   *
   * @class Server
   * @method config
   * @return {void}
   */
  public config(): void {
    // mount query string parser
    this.app.use(bodyParser.urlencoded({
      extended: true
    }))

    // mount json form parser
    this.app.use(bodyParser.json())

    // mount cookie parker
    this.app.use(cookieParser())

    // mount logger
    this.app.use(logger("dev"))
    
    // mount compression
    this.app.use(compression())
    
    // mount helmet
    this.app.use(helmet())
    
    // mount cors
    this.app.use(cors())

    // cors
    // this.app.use((req: Request, res: Response, next: NextFunction) => {
    //   res.header('Access-Control-Allow-Origin', 'http://localhost:8080')
    //   res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, PATCH, DELETE, OPTIONS, PURGE')
    //   res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization, Access-Control-Allow-Credentials')
    //   res.header('Access-Control-Allow-Credentials', 'true')
    //   next()
    // })
  }

	public setup() {
		this.logger.debug("Enabling GZip compression.");

        this.app.use(expressCompression({
            threshold: 512,
        }));

		this.logger.debug("GZip compression enabled.");
	}

export const expressConfig = (): core.Express => {
  const app: core.Express = express();
  app.use(bodyParser.json({ limit: '50mb' }));
  app.use(bodyParser.urlencoded({ limit: '50mb', extended: true }));
  app.use(cookieParser());
  app.use(express.static(path.join(__dirname, 'assets')));
  app.use(cors());
  app.use(compression({filter: shouldCompress}));

  return app;
};

const addProdMiddlewares = (app: Express.Application, options: IOptions) => {
  const publicPath = options.publicPath || '/';
  const outputPath = options.outputPath || Path.resolve(process.cwd(), 'build');

  // compression middleware compresses your server responses which makes them
  // smaller (applies also to assets). You can read more about that technique
  // and other good practices on official Express.js docs http://mxs.is/googmy
  app.use(Compression());
  app.use(publicPath, Express.static(outputPath));

  app.get('*', (req, res) => res.sendFile(Path.resolve(outputPath, 'index.html')));
};

export function preconfigExpress() {
  var app = express();

  if (config.ENV === 'prod') {
    app.use(compress());
  } else {
    app.use(morgan('dev'));
  }

  app.use(bodyParser.urlencoded({
    extended: true
  }));
  app.use(bodyParser.json());
  app.use(methodOverride());

  // app.use(session({
  //   saveUninitialized: true,
  //   resave: true,
  //   secret: config.SESSION_SECRET
  // }));

  // app.set('views', normalize(join(__dirname, 'src/core/server/views')));
  // app.set('view engine', 'ejs');

  route.routes(app);

  app.use(express.static(normalize(__dirname)));

  return app;
}

export function createJSONServer(port: number, queryProcessor: JSONQueryProcessor): void {
  var app = express();
  app.disable('x-powered-by');

  app.use(compress());

  app.get('/health', (req: Request, res: Response) => {
    res.send(`I am healthy @ ${new Date().toISOString()}`);
  });

  app.use(bodyParser.json());
  app.post('/plyql', (req: Request, res: Response) => {
    var { sql } = req.body;

    if (typeof sql !== "string") {
      res.status(400).json({ error: "'sql' must be a string" });
      return;
    }

    console.log(`Got SQL: ${sql}`);
    queryProcessor({ sql }, res);
  });

  app.use((err: any, req: Request, res: Response, next: Function) => {
    res.status(err.status || 500);
    res.json({ error: err.message });
  });

  var server = http.createServer(app);

  server.on('error', (error: any) => {
    if (error.syscall !== 'listen') {
      throw error;
    }

    // handle specific listen errors with friendly messages
    switch (error.code) {
      case 'EACCES':
        console.error(`Port ${port} requires elevated privileges`);
        process.exit(1);
        break;

      case 'EADDRINUSE':
        console.error(`Port ${port} is already in use`);
        process.exit(1);
        break;

      default:
        throw error;
    }
  });

  server.on('listening', () => {
    var address = server.address();
    console.log('PlyQL server listening on port: ' + address.port);
  });

  app.set('port', port);
  server.listen(port);
}