mostly working version with latest libraries

1 files changed, 12 insertions, 22 deletions

diff --git a/src/server/server_Initialization.ts b/src/server/server_Initialization.ts
index af8b8dfdd..a4deaa744 100644
--- a/src/server/server_Initialization.ts
+++ b/src/server/server_Initialization.ts
@@ -1,13 +1,10 @@
 import * as bodyParser from 'body-parser';
 import { blue, yellow } from 'colors';
-import * as cookieParser from 'cookie-parser';
 import * as cors from 'cors';
 import * as express from 'express';
 import * as session from 'express-session';
 import * as expressValidator from 'express-validator';
-import * as fs from 'fs';
-import { Server as HttpServer } from 'http';
-import { createServer, Server as HttpsServer } from 'https';
+import { createServer } from 'https';
 import * as passport from 'passport';
 import * as request from 'request';
 import * as webpack from 'webpack';
@@ -22,10 +19,10 @@ import { Database } from './database';
 import RouteManager from './RouteManager';
 import RouteSubscriber from './RouteSubscriber';
 import { WebSocket } from './websocket';
-import * as brotli from 'brotli';
 import * as expressFlash from 'express-flash';
 import * as flash from 'connect-flash';
-import * as  MongoStoreConnect from 'connect-mongo';
+import * as brotli from 'brotli';
+import * as MongoStoreConnect from 'connect-mongo';
 import * as config from '../../webpack.config';
 
 /* RouteSetter is a wrapper around the server that prevents the server
@@ -41,29 +38,21 @@ export default async function InitializeServer(routeSetter: RouteSetter) {
     const app = buildWithMiddleware(express());
     const compiler = webpack(config as any);
 
-    app.use(
-        require('webpack-dev-middleware')(compiler, {
-            publicPath: config.output.publicPath,
-        })
-    );
-
-    app.use(require('webpack-hot-middleware')(compiler));
-
     // route table managed by express.  routes are tested sequentially against each of these map rules.  when a match is found, the handler is called to process the request
+    app.use(wdm(compiler, { publicPath: config.output.publicPath }));
+    app.use(whm(compiler));
     app.get(new RegExp(/^\/+$/), (req, res) => res.redirect(req.user ? '/home' : '/login')); // target urls that consist of one or more '/'s with nothing in between
     app.use(express.static(publicDirectory, { setHeaders: res => res.setHeader('Access-Control-Allow-Origin', '*') })); //all urls that start with dash's public directory: /files/  (e.g., /files/images, /files/audio, etc)
     app.use(cors({ origin: (_origin: any, callback: any) => callback(null, true) }));
-    app.use(wdm(compiler, { publicPath: config.output.publicPath }));
-    app.use(whm(compiler));
     registerAuthenticationRoutes(app); // this adds routes to authenticate a user (login, etc)
     registerCorsProxy(app); // this adds a /corsProxy/ route to allow clients to get to urls that would otherwise be blocked by cors policies
     isRelease && !SSL.Loaded && SSL.exit();
     routeSetter(new RouteManager(app, isRelease)); // this sets up all the regular supervised routes (things like /home, download/upload api's, pdf, search, session, etc)
     registerEmbeddedBrowseRelativePathHandler(app); // this allows renered web pages which internally have relative paths to find their content
 
-    let server: HttpServer | HttpsServer;
     isRelease && process.env.serverPort && (resolvedPorts.server = Number(process.env.serverPort));
-    await new Promise<void>(resolve => (server = isRelease ? createServer(SSL.Credentials, app).listen(resolvedPorts.server, resolve) : app.listen(resolvedPorts.server, resolve)));
+    const server = isRelease ? createServer(SSL.Credentials, app) : app;
+    await new Promise<void>(resolve => server.listen(resolvedPorts.server, resolve));
     logPort('server', resolvedPorts.server);
 
     resolvedServerUrl = `${isRelease && process.env.serverName ? `https://${process.env.serverName}.com` : 'http://localhost'}:${resolvedPorts.server}`;
@@ -78,26 +67,27 @@ export default async function InitializeServer(routeSetter: RouteSetter) {
 
 const week = 7 * 24 * 60 * 60 * 1000;
 const secret = '64d6866242d3b5a5503c675b32c9605e4e90478e9b77bcf2bc';
+const store = process.env.DB === 'MEM' || true ? new session.MemoryStore() : MongoStoreConnect.create({ mongoUrl: Database.url });
 
 function buildWithMiddleware(server: express.Express) {
     [
-        cookieParser(),
         session({
             secret,
             resave: true,
             cookie: { maxAge: week },
             saveUninitialized: true,
-            store: process.env.DB === 'MEM' ? new session.MemoryStore() : MongoStoreConnect.create({ mongoUrl: Database.url }),
+            store,
         }),
         flash(),
         expressFlash(),
         bodyParser.json({ limit: '10mb' }),
         bodyParser.urlencoded({ extended: true }),
-        expressValidator.body,
+        expressValidator(), // adds functions (e.g., assert()) to 'req' that help validate the request in the route handling methods
         passport.initialize(),
         passport.session(),
         (req: express.Request, res: express.Response, next: express.NextFunction) => {
             res.locals.user = req.user;
+            console.log('HEADER:' + req.originalUrl + ' path = ' + req.path);
             if ((req.originalUrl.endsWith('.png') || req.originalUrl.endsWith('.jpg') || (process.env.RELEASE === 'true' && req.originalUrl.endsWith('.js'))) && req.method === 'GET') {
                 const period = 30000;
                 res.set('Cache-control', `public, max-age=${period}`);
@@ -108,7 +98,7 @@ function buildWithMiddleware(server: express.Express) {
             next();
         },
     ].forEach(next => server.use(next));
-    
+
     return server;
 }