TypeScript express.static函数代码示例

function start(workingDir?: string): void {
    workingDir = workingDir || __dirname;
    // Setup
    let app = express(),
        serverPort = 3000,
        debug = true;


    // View Engine setup
    app.set('views', path.join(workingDir, 'views'));
    app.set('view engine', 'jade');

    // Configuration
    app.disable('etag'); // Disables etags for JSON requests
    // app.use(favicon(workingDir + '/public/assets/favicon.ico'));
    app.use(morgan('dev', { stream: logger.toStream() }));
    app.use(lessMiddleware(path.join(workingDir, 'public'), {
        force: true,
        debug: debug,
    }));
    app.use(bodyParser.json());
    app.use(express.static(path.join(workingDir, 'public'), { etag: true }));

    // Initialize Event Sourcing infrastructure
    esManager
        .configure(registry => {
            let serviceGroupListener = new ServiceGroupModelListener();
            registry
                .command(ServiceGroupCommands.CreateServiceGroup).handledBy(new CreateServiceGroupHandler())
                .command(ServiceGroupCommands.AddService).handledBy(new AddServiceHandler())
                .event(ServiceGroup.Events.ServiceGroupCreated).triggers(evt => serviceGroupListener.handleCreated(evt))
                .event(ServiceGroup.Events.ServiceAdded).triggers(evt => serviceGroupListener.handleServiceAdded(evt));
        })
        .start();

    // Main SPA route
    app.get('/', (req: Request, res: Response) => res.render('layout', {}));

    // APIs
    let controllers = [
        new ServiceGroupApi(),
    ];
    controllers.forEach(ctrl => app.use(ctrl.routes()));

    // Error handlers
    app.use((req: Request, res: Response, next: Function) => {
        var message = `Could not find resource: ${req.url}`,
            err = new Error(message);
        err['status'] = 404;
        next(err);
    });

    app.use((err: Error, req: Request, res: Response, next:Function) => {
        let errorId = Utils.uuid();
        res.status(err['status'] || 500);
        res.send({
            id: errorId,
            message: err.message,
            stack: debug === true ? err.stack.split('\n') : undefined
        });
    });

    // Setup server
    let port = serverPort;
    app.set('port', port);
    let server = http.createServer(app);

    logger.info(`Server listening on port ${port}`);
    server.listen(port);
    server.on('error', (error: any) => {
        if (error.syscall !== 'listen') {
            throw error;
        }

        let bind = typeof port === 'string'
            ? 'Pipe ' + port
            : 'Port ' + port;

        // Handle specific listen errors with friendly messages
        switch (error.code) {
            case 'EACCES':
                logger.error(bind + ' requires elevated privileges');
                process.exit(1);
                break;
            case 'EADDRINUSE':
                logger.error(bind + ' is already in use');
                process.exit(1);
                break;
            default:
                throw error;
        }
    });

    server.on('listening', () => {
        let addr = server.address(),
            bind = typeof addr === 'string'
                ? 'pipe ' + addr
                : 'port ' + addr.port;
        logger.info('Listening on ' + bind);
    });
//.........这里部分代码省略.........

        .forEach((mod) => { console.log(Mod.parseFromJson(JSON.stringify((mod)))); });
});

let app: Express = express();

// view engine setup
app.set("views", path.join(__dirname, "views"));
app.set("view engine", "jade");

// uncomment after placing your favicon in /public
// app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger("dev"));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(cookieParser());
app.use(express.static(path.join(__dirname, "public")));

app.use("/", index.router);
app.use("/users", users.router);

// catch 404 and forward to error handler
app.use(function(req: Request, res: Response, next: NextFunction) {
    let err: HttpError = Error("Not Found");
    err.status = 404;
    next(err);
});

// error handlers

// development error handler
// will print stacktrace

export default async (app: Application) => {
  if (config.database) {
    mongoose.connect(
      config.database.params.connection_string,
      {
        useNewUrlParser: true,
      },
    );
  }

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

  if (config.sessions) {
    app.use(clientSessions(config.sessions));
  }

  if (config.templates) {
    app.engine(config.templates.type, (await import(config.templates.type)).default.__express);
    app.set("view engine", config.templates.type);
  }

  if (config.pages) {
    config.pages.forEach((pageConfig: IPage) => {
      app.get(pageConfig.route, (_req: IRequest, res: Response) => {
        // req.headers
        if (pageConfig.template) {
          res.render(pageConfig.template, pageConfig.parameters);
        } else {
          res.status(200).json(pageConfig.parameters);
        }
      });
    });
  }

  if (config.static) {
    app.use(expressStatic(`__dirname${config.static}`));
  }

  if (config.collections) {
    config.collections.forEach((schema: ISchema) => {
      const modelSchema = model(schema);
      app.get(`/${schema.name}`, async (_req: IRequest, res: Response) =>
        res.status(200).json(await modelSchema.find()),
      );
      app.get(`/${schema.name}/:id`, async (req: IRequest, res: Response) => {
        try {
          res.status(200).json(await modelSchema.findOne({_id: req.params.id}));
        } catch (err) {
          res.status(404).json({error: "Not Found"});
        }
      });
      app.post(`/${schema.name}`, async (req: IRequest, res: Response) => {
        try {
          const newModel = new modelSchema(req.body);
          await newModel.save();
          res.status(201).json(newModel);
        } catch (err) {
          res.status(400).json({error: err.message});
        }
      });
      /*
      app.put(`/${schema.name}/:id`, async (req: IRequest, res: Response) => {
        //
      });
      app.patch(`/${schema.name}/:id`, async (req: IRequest, res: Response) => {
        //
      });
      app.delete(`/${schema.name}/:id`, (req: IRequest, res: Response) => {
        //
      });
      */
    });
  }

  /*if (config.auth) {
    config.auth.forEach((authConfig: IAuthConfig) => {
      //
    });
  }*/
};

        }
    }));
    app.set('views',__dirname + '/server/views/dev');
}else{
    app.set('views',__dirname + '/public/demo');
}

app.set('view engine', 'html');
app.engine('.html', require('ejs').__express)


app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
app.use(methodOverride());
app.use(cookieParser());
app.use(express.static(__dirname+'/public'));

// Routes
app.get('/demo/index',index.index);
app.get('/demo/picker',index.index);
app.get('/demo/toast',index.index);
app.get('/demo/alert',index.index);
app.get('/demo/preloader',index.index);
app.get('/demo/indicator',index.index);
app.get('/demo/actions',index.index);
app.get('/demo/pullToRefresh',index.index);
app.get('/demo/infiniteScroll',index.index);

//错误处理
app.get('/*',function(req,res){
   res.writeHead(301,{

require('./api/cars/car.model');
require('./api/users/user.model');
mongoose.connect(MONGO_URL, (err) => {
    if (err) console.error(err);
    else console.log(`Connected to ${MONGO_URL}`);
});

// Render jade files for the client
// TODO: add gulp task to compile jade to html, and send back that html instead of rendering jade
app.get(/\/client.{0,}\/.+\.jade/, (req, res, next) => {
    res.render(config.root + req.path);
});

// Routes Config
app.use(require('body-parser')());
app.use('/client', express.static('client'));
app.use('/bower_components', express.static('bower_components'));

// Routes
app.get('/', (req, res, next) => {
    res.sendFile(config.client + '/index.html');
});

app.use('/api/v1/cars', require('./api/cars/car.routes'));
app.use('/api/v1/users', require('./api/users/user.routes'));

// if path starts with /client, /bower_components, or /api, send a 404
app.get(/\/(client|bower_components|api).{0,}/, (req, res, next) => {
    next({ status: 404, message: `${req.path} is not found, or does not exist. Please check for typos.` });
});

const gameServer = new Server({
  // engine: WebSocket.Server,
  server: server
});

// Register ChatRoom as "chat"
gameServer.register("chat", ChatRoom).then((handler) => {
  // demonstrating public events.
  handler.
    on("create", (room) => console.log("room created!", room.roomId)).
    on("join", (room, client) => console.log("client", client.id, "joined", room.roomId)).
    on("leave", (room, client) => console.log("client", client.id, "left", room.roomId)).
    on("dispose", (room) => console.log("room disposed!", room.roomId));
})

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

app.get("/something", (req, res) => {
  console.log("something!", process.pid);
  console.log("GET /something")
  res.send("Hey!");
});

app.post("/something", (req, res) => {
  console.log("POST /something")
  res.json(req.body);
});

gameServer.onShutdown(() => {
  console.log("CUSTOM SHUTDOWN ROUTINE: STARTED");
  return new Promise((resolve, reject) => {

// Import module map for lazy loading
import { provideModuleMap } from '@nguniversal/module-map-ngfactory-loader';

app.engine('html', ngExpressEngine({
  bootstrap: AppServerModuleNgFactory,
  providers: [
    provideModuleMap(LAZY_MODULE_MAP)
  ]
}));

app.set('view engine', 'html');
app.set('views', join(DIST_FOLDER, 'browser'));

// TODO: implement data requests securely
app.get('/api/*', (req, res) => {
  res.status(404).send('data requests are not supported');
});

// Server static files from /browser
app.get('*.*', express.static(join(DIST_FOLDER, 'browser')));

// All regular routes use the Universal engine
app.get('*', (req, res) => {
  res.render('index', { req });
});

// Start up the Node server
app.listen(PORT, () => {
  console.log(`Node server listening on http://localhost:${PORT}`);
});

app.use(compression());

const accessLogStream = fs.createWriteStream(ROOT + '/morgan.log', {flags: 'a'})

app.use(morgan('common', {
  skip: (req, res) => res.statusCode < 400,
  stream: accessLogStream
}));

function cacheControl(req, res, next) {
  // instruct browser to revalidate in 60 seconds
  res.header('Cache-Control', 'max-age=60');
  next();
}
// Serve static files
app.use('/assets', cacheControl, express.static(path.join(__dirname, 'assets'), {maxAge: 30}));
app.use(cacheControl, express.static(path.join(ROOT, 'dist/client'), {index: false}));

//
/////////////////////////
// ** Example API
// Notice API should be in aseparate process

import { serverApi, createTodoApi } from './backend/api';
// Our API for demos only
app.get('/data.json', serverApi);
app.use('/api', createTodoApi());

process.on('uncaughtException', function (err) { 
  console.error('Catching uncaught errors to avoid process crash', err);
});

const swaggerJSON = require('./swagger.json')

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

RegisterRoutes(app)
app.get(`/`, (req, res) => {
  res.redirect(`${basePath}swagger`)
})
app.use(`${basePath}healthz`, (_, res) => {
  res.send({
    status: 'Healthy!'
  })
})
app.use(`${basePath}swagger.json`, express.static(__dirname + './swagger.json'))
app.use(`${basePath}swagger`, swaggerUI.serve, swaggerUI.setup(swaggerJSON))

function startServer() {
  app.listen(process.env.PORT || 5002, () => {
    console.info(`App's running at http://localhost:${process.env.PORT || 5002}`)
    console.info('Press CTRL-C to stop\n')
  })
}

mongoose.connection.once('open', function() {
  console.info(`Connected to ${mongoDbUri}.`)
  app.emit('ready')
})

app.on('ready', function() {

    // Get all js files.
    recursive(SCRIPT_DIR, function (err, files) {
        files.forEach((filePath:string) => {
            if (filePath.indexOf(".map") < 0) {
                var path:string = filePath.substr(filePath.indexOf('js'));
                scriptList.push(
                    {
                        scriptPath: path
                    }
                );
            }
        });

        res.render("index.html", {
            scripts: scriptList
        });
    });
});

app.use(express.static(__dirname + "/../public/"));

// handle any 404 requests
var routes = app._router.stack.filter(router => {return router.route}).map(router => {return router.route.stack.map(stack => {return `${stack.method.toUpperCase()} \t${router.route.path}`}).join("\n")}).join("\n");
app.use(function(req, res){
    res.status(404).contentType("text/plain").send(`Could not ${req.method} ${req.path}\nTry:\n\n${routes}`)
});
app.listen(port, function(){
    console.log(`Listening to port:${port}`);
    console.log(`Routes:\n${routes}`);
});