TypeScript express Router Examples

Example #1

File: index.ts Project: ZulusK/Budgetarium

import * as express from "express";
import {NextFunction, Request, Response, Router} from "express";
import * as path from "path";
import {GraphQLRouter} from "@GraphQL/index";
import {Logger} from "@utils";
import config from "@config";

const logs = Logger(module);
const router: Router = express.Router();

function error404(req: Request, res: Response, next: NextFunction): void {
    logs.debug("Not found URL: %s", req.url);
    const err: any = new Error("Not found");
    err.status = 404;
    next(err);
}

function onError(err: any, req: Request, res: Response): void {
    logs.error("Internal error(%d): %s", res.statusCode, err.message);
    res.locals.message = err.message;
    res.locals.error = config.get("isDev") ? err : {};
    res.status(err.status || 500);
    res.json({
        message: err.message || "Server error",
    });
}

function onSPA(req: Request, res: Response): void {
    logs.info(path.join(__dirname,"../public/index.html"));
    res.sendFile(path.join(__dirname, "../public/index.html"));
}

Example #2

File: collaborator.route.ts Project: twicepixels/tp-main-api

import { Router } from 'express';
var authenticatedPolicy = require("../../policies/authenticated");
import { CollaboratorController } from "../../../app/controllers/collaborator/collaborator.controller";

export const COLLABORATOR_MAIN_ROUTER: Router = Router();
// define routes
//create
COLLABORATOR_MAIN_ROUTER.post('/', CollaboratorController.create);
//getById
COLLABORATOR_MAIN_ROUTER.get('/:id', authenticatedPolicy, CollaboratorController.getById);
//getAll
COLLABORATOR_MAIN_ROUTER.post('/getAll', CollaboratorController.getAll);
//update
COLLABORATOR_MAIN_ROUTER.put('/:id', authenticatedPolicy, CollaboratorController.updateById);

//delete
COLLABORATOR_MAIN_ROUTER.delete('/:id', authenticatedPolicy, CollaboratorController.deleteById);

Example #3

File: index.ts Project: todd/express_ts

import {Router} from 'express';

const index: Router = Router();

index.get('/', (req, res, next) => {
   res.send('foobar'); 
});

export default index;

Example #4

File: auth.ts Project: KShewengerz/ngx-express-passport-setup

"use strict";

import { Router } from "express";

import { Passport } from "../server";
import * as userApi from "../controllers/user";

const router: Router = Router();
const frontEndOriginUrl = process.env.FRONTEND_URL;
const frontEndInitializeUrl = `${frontEndOriginUrl}/initialize`;


/**
 * @api {get} /google
 * @description Passport Google Authentication - Holds the redirection from your app to gmail login page.
 */
router.get("/google", Passport.authenticate("google", { scope: [ "profile", "email" ] }));


/**
 * @api {get} /google/callback
 * @description Handles the callback after google has authenticated the user.
 *
 * * @successRedirect 1 is enum value for Facebook. Facebook ang Google both uses localhost except for twitter 127.0.0.1.
 * This will be filtered out on Front End and set the base url as either localhost or 127.0.0.1 base on the enum id used.
 */
router.get("/google/callback", Passport.authenticate("google", {
  successRedirect: `${frontEndInitializeUrl}/1`,
  failureRedirect: "/"
}));

Example #5

File: users.ts Project: thorti1985/pl_mean

import { Router, Request, Response } from "express";

const usersRouter: Router = Router();

usersRouter.get("/", function (req: Request, res: Response, next: any) {
    res.send("respond with a resource");
});

export {usersRouter}

Example #6

File: study_entity.ts Project: akazimirov/domic

import { Router, Response, Request } from 'express';

export const studyEntityRouter: Router = Router();

studyEntityRouter.get('/', (request: Request, response: Response) => {
  response.json([  {id: 1, name: 'Qrwerewrwe', content: {html: '<h1>asdfsdf</h2><p>asdfasdfasdfasdf</p>'}},
  {id: 2, name: 'Nererew', content: {html: '<h1>asdfsdf</h2><p>asdfasdfasdfasdf</p>'}},
  {id: 3, name: 'Boewrewr', content: {html: '<h1>asdfsdf</h2><p>asdfasdfasdfasdf</p>'}},
  {id: 4, name: 'Celeritas', content: {html: '<h1>asdfsdf</h2><p>asdfasdfasdfasdf</p>'}},
  {id: 5, name: 'Magneta', content: {html: '<h1>asdfsdf</h2><p>asdfasdfasdfasdf</p>'}},
  {id: 6, name: 'RubberMan', content: {html: '<h1>asdfsdf</h2><p>asdfasdfasdfasdf</p>'}},
  {id: 7, name: 'Dynama', content: {html: '<h1>asdfsdf</h2><p>asdfasdfasdfasdf</p>'}},
  {id: 8, name: 'Dewrew', content: {html: '<h1>asdfsdf</h2><p>asdfasdfasdfasdf</p>'}},
  {id: 9, name: 'Magma', content: {html: '<h1>asdfsdf</h2><p>asdfasdfasdfasdf</p>'}},
  {id: 10, name: 'Tornado', content: {html: '<h1>asdfsdf</h2><p>asdfasdfasdfasdf</p>'}}
  ]);
});

studyEntityRouter.get('/:id', (request: Request, response: Response) => {
  response.json(
      {id: 3, name: 'Boewrewr', content: {html: '<h1>asdfsdf</h2><p>asdfasdfasdfasdf</p>'}}
  );
});

Example #7

File: index.ts Project: TeddyRandby/ChemistryAgainstHumanity

    public static create(router: Router) {
        // log
        console.log("[IndexRoute::create] Creating index route.");

        // add home page route
        router.get("/", (req: Request, res: Response, next: NextFunction) => {
            new IndexRoute().index(req, res, next);
        });

        // we will post to the root if we have a login fail
        router.post("/", (req: Request, res: Response, next: NextFunction) => {
            new IndexRoute().index(req, res, next);
        });

        // router.post("/login", (req: Request, res: Response, next: NextFunction) => {
        //     new IndexRoute().login(req, res, next);
        // });
        
        //add admin page to import reactions and get depictions
        router.post("/admin", (req: Request, res: Response, next: NextFunction) => {
            new IndexRoute().admin(req, res, next);
        });

        //if accessed through GET request or directly by URL
        router.get("/admin", (req: Request, res: Response, next: NextFunction) => {
            res.send("You either do not have permission to access this page, or you are trying to access it directly.  If you are an admin, please authenticate and try again.")
        })

        // handles ajax request to get depictions
        router.post("/getImage", (req: Request, res: Response, next: NextFunction) => {
            new IndexRoute().getImage(req, res, next);
        });
        
        //add game page route POST --> in class mode with leaderboard after user authentication
        router.post("/game", (req: Request, res: Response, next: NextFunction) => {
            //new IndexRoute().game(req, res, next);
            new IndexRoute().login(req, res, next);
        });

        //GET --> practice mode, no leaderboard effect
        router.get("/game", (req: Request, res: Response, next: NextFunction) => {
            new IndexRoute().game(req, res, next);
        });

        //insert reaction and cards to db
	    router.post("/addReaction", (req: Request, res: Response, next: NextFunction) => {
	        new IndexRoute().addReaction(req, res, next);
	    });
    
        //return 'deck' of cards from db for game use
	    router.post("/generateCards", (req: Request, res: Response, next: NextFunction) => {
            new IndexRoute().generateCards(req, res, next);
        });

        //return set of all reactions in db for solution checking
        router.post("/generateSolutions", (req: Request, res: Response, next: NextFunction) => {
            new IndexRoute().generateSolutions(req, res, next);
        });

        //export current reactions from db to csv file for download
        router.get("/exportReactions", (req: Request, res: Response, next: NextFunction) => {
            new IndexRoute().exportReactions(req, res, next);
        });

        //export users and points from db to csv file for download
        router.get("/exportPoints", (req: Request, res: Response, next: NextFunction) => {
            new IndexRoute().exportPoints(req, res, next);
        });

        //reset all user points to 0
        router.get("/resetPoints", (req: Request, res: Response, next: NextFunction) => {
            new IndexRoute().resetPoints(req, res, next);
        });

        router.get("/getLeaderboard", (req: Request, res: Response, next: NextFunction) => {
            new IndexRoute().getLeaderboard(req, res, next);
        });

        router.post("/updateLeaderboard", (req: Request, res: Response, next: NextFunction) => {
            new IndexRoute().updateLeaderboard(req, res, next);
        })

    }

Example #8

File: router.ts Project: twicepixels/tp-main-api

import { Router } from "express";
import { COLLABORATOR_MAIN_ROUTER } from "./collaborator.route";
import { IMAGE_ROUTER } from "./image.route";

let router: Router = Router();
router.use("/", COLLABORATOR_MAIN_ROUTER);
router.use("/image", IMAGE_ROUTER);

export const COLLABORATOR_ROUTER: Router = router;

Example #9

File: tracks.ts Project: StaceC/implib

import {Router, Request, Response } from 'express';
import db from "../../db";
import fs = require("fs");
import path = require("path");
import config from "../../config";
const SAVE_DIR = config.settings.saveDir;

const router: Router = Router();

// GET tracks listing.
router.get('/', (req: Request, res: Response) => {
  db.Track.findAll({ raw: true })
  .then(tracks => res.send(tracks));
});

// Get track info.
router.get('/:trackId', (req: Request, res: Response) => {
  const trackId = req.params.trackId;
  db.Track.findById(trackId)
  .then(track => res.send(track));
});

// Get todo info.
router.get('/:trackId/config', (req: Request, res: Response) => {
  const trackId = req.params.trackId;
  db.Track.findById(trackId)
  .then((track) => {
    if(track) {
      const configFilePath = path.join(SAVE_DIR, track.name, "config.json");
      fs.readFile(configFilePath, 'utf8', function(err, data) {
        if (err) {

Example #10

File: protected.ts Project: BLamy/angular2-express-starter

import { Router, Response } from "express";
import { verify } from "jsonwebtoken";
import { secret } from "../config";

const protectedRouter: Router = Router();

protectedRouter.use(function(req: any, res: Response, next) {
    const token = req.headers.auth;
    console.log(token);
    verify(token, secret, function(tokenError) {
        if (tokenError) {
            return res.status(500).json({
                message: "Invalid token, please Log in first"
            });
        }

        next();
    });
});

protectedRouter.get("/", function(req, res) {
    res.json({
        text: "Greetings, you have valid token.",
        title: "Protected call"
    });
});

export {protectedRouter}