.env.example

@@ -4,5 +4,4 @@ DB_HOST=bla
 DB_PORT=bla
 DB_USER=bla
 DB_PASSWORD=bla
-DB_NAME=bla
+DB_NAME=bla
-NODE_ENV=production

src/app.ts

@@ -5,25 +5,22 @@ import consola from "consola";
 import loaders from "./loaders/index";
 import authchecker from "./authchecker";
 import { ErrorHandler } from './middlewares/ErrorHandler';
-
+// 
 dotenvSafe.config();
 const PORT = process.env.APP_PORT || 4010;
 
 const app = createExpressServer({
-  authorizationChecker: authchecker,
+    authorizationChecker: authchecker,
-  middlewares: [ErrorHandler],
+    middlewares: [ErrorHandler],
-  development: process.env.NODE_ENV === "production",
+    development: false,
-  cors: true,
+    controllers: [`${__dirname}/controllers/*.ts`],
-  routePrefix: "/api",
-  controllers: [__dirname + "/controllers/*.ts"],
 });
 
-async function main() {
+(async () => {
-  await loaders(app);
+    await loaders(app);
-  app.listen(PORT, () => {
+    app.listen(PORT, () => {
-    consola.success(
+        consola.success(
-      `⚡️[server]: Server is running at http://localhost:${PORT}`
+            `⚡️[server]: Server is running at http://localhost:${PORT}`
-    );
+        );
-  });
+    });
-}
+})();
-main();

src/controllers/TrackController.ts

@@ -1,92 +1,64 @@
-import { JsonController, Param, Body, Get, Post, Put, Delete, NotFoundError, OnUndefined, NotAcceptableError, Authorized } from 'routing-controllers';
+import {
-import { getConnectionManager, Repository } from 'typeorm';
+  JsonController,
-import { EntityFromBody } from 'typeorm-routing-controllers-extensions';
+  Param,
-import { OpenAPI, ResponseSchema } from 'routing-controllers-openapi';
+  Body,
-import { Track } from '../models/Track';
+  Get,
-import { IsInt, IsNotEmpty, IsPositive, IsString } from 'class-validator';
+  Post,
+  Put,
+  Delete,
+  Authorized,
+} from "routing-controllers";
+import { getConnectionManager, Repository } from "typeorm";
+import { EntityFromBody } from "typeorm-routing-controllers-extensions";
+import { ResponseSchema } from "routing-controllers-openapi";
+import { Track } from "../models/Track";
+import { IsInt, IsNotEmpty, IsPositive, IsString } from "class-validator";
 
 class CreateTrack {
-	@IsString()
+  @IsString()
-	@IsNotEmpty()
+  @IsNotEmpty()
-	name: string;
+  name: string;
 
-	@IsInt()
+  @IsInt()
-	@IsPositive()
+  @IsPositive()
-	length: number;
+  length: string;
 }
 
-export class TrackNotFoundError extends NotFoundError {
+@JsonController("/track")
-	constructor() {
+// @Authorized("TRACKS:read")
-		super('Track not found!');
-	}
-}
-
-@JsonController('/tracks')
-@Authorized("TRACKS:read")
 export class TrackController {
-	private trackRepository: Repository<Track>;
+  private trackRepository: Repository<Track>;
 
-	/**
+  constructor() {
-	 * Gets the repository of this controller's model/entity.
+    this.trackRepository = getConnectionManager().get().getRepository(Track);
-	 */
+  }
-	constructor() {
-		this.trackRepository = getConnectionManager().get().getRepository(Track);
-	}
 
-	@Get()
+  @Get()
-	@ResponseSchema(Track, { isArray: true })
+  @ResponseSchema(Track, { isArray: true })
-	@OpenAPI({ description: "Lists all tracks." })
+  getAll() {
-	getAll() {
+    return this.trackRepository.find();
-		return this.trackRepository.find();
+  }
-	}
 
-	@Get('/:id')
+  @Get("/:id")
-	@ResponseSchema(Track)
+  @ResponseSchema(Track)
-	@OnUndefined(TrackNotFoundError)
+  getOne(@Param("id") id: number) {
-	@OpenAPI({ description: "Returns a track of a specified id (if it exists)" })
+    return this.trackRepository.findOne({ id: id });
-	getOne(@Param('id') id: number) {
+  }
-		return this.trackRepository.findOne({ id: id });
-	}
 
-	@Post()
+  @Authorized()
-	@ResponseSchema(Track)
+  @Post()
-	@OpenAPI({ description: "Create a new track object (id will be generated automagicly)." })
+  post(@Body({ validate: true }) track: CreateTrack) {
-	post(
+    return this.trackRepository.save(track);
-		@Body({ validate: true })
+  }
-		track: CreateTrack
-	) {
-		return this.trackRepository.save(track);
-	}
 
-	@Put('/:id')
+  @Authorized("TRACKS:write")
-	@ResponseSchema(Track)
+  @Put("/:id")
-	@OpenAPI({ description: "Update a track object (id can't be changed)." })
+  put(@Param("id") id: number, @EntityFromBody() track: Track) {
-	async put(@Param('id') id: number, @EntityFromBody() track: Track) {
+    return this.trackRepository.update({ id: id }, track);
-		let oldTrack = await this.trackRepository.findOne({ id: id });
+  }
 
-		if (!oldTrack) {
+  @Delete("/:id")
-			throw new TrackNotFoundError();
+  remove(@Param("id") id: number) {
-		}
+    return this.trackRepository.delete({ id: id });
-
+  }
-		if (oldTrack.id != track.id) {
-			throw new NotAcceptableError("The id's don't match!");
-		}
-
-		await this.trackRepository.update(oldTrack, track);
-		return track;
-	}
-
-	@Delete('/:id')
-	@ResponseSchema(Track)
-	@OpenAPI({ description: "Delete a specified track (if it exists)." })
-	async remove(@Param('id') id: number) {
-		let track = await this.trackRepository.findOne({ id: id });
-
-		if (!track) {
-			throw new TrackNotFoundError();
-		}
-
-		await this.trackRepository.delete(track);
-		return track;
-	}
 }

src/loaders/express.ts

@@ -3,6 +3,12 @@ import bodyParser from 'body-parser';
 import cors from 'cors';
 
 export default async (app: Application) => {
+	app.get('/status', (req, res) => res.status(200).end());
 	app.enable('trust proxy');
+
+	app.use(cors());
+	// app.use(bodyParser.urlencoded({ extended: false }));
+
+	// more middlewares
 	return app;
 };

src/loaders/openapi.ts

@@ -11,9 +11,7 @@ export default async (app: Application) => {
   });
   const spec = routingControllersToSpec(
     storage,
-    {
+    {},
-      routePrefix: "/api"
-    },
     {
       components: {
         schemas,
@@ -29,11 +27,11 @@ export default async (app: Application) => {
     explorer: true,
   };
   app.use(
-    "/api/docs",
+    "/docs",
     swaggerUiExpress.serve,
     swaggerUiExpress.setup(spec, options)
   );
-  app.get(["/api/openapi.json", "/api/swagger.json"], (req, res) => {
+  app.get(["/openapi.json", "/swagger.json"], (req, res) => {
     res.json(spec);
   });
   return app;

src/models/Track.ts

@@ -7,12 +7,6 @@ import {
   IsString,
 } from "class-validator";
 
-/**
- * @classdesc Defines a track of given length.
- * @property {number} id - Autogenerated unique id
- * @property {string} name - The track's name
- * @property {number} lenth - The track's length in meters
-*/
 @Entity()
 export class Track {
   @PrimaryGeneratedColumn()
@@ -28,5 +22,5 @@ export class Track {
   @Column()
   @IsInt()
   @IsPositive()
-  length: number;
+  length: string;
 }