@sjoblomtobias/relay 1.0.0 → 2.0.0

package/LICENSE

@@ -1,21 +1,20 @@
-MIT License
+Pirate License
 
-Copyright (c) 2025 Tobias Sjöblom
+Copyright (c) 2026 Tobias Sjöblom
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Avast! Permission be hereby granted, free o’ charge, to any scallywag obtainin’ a copy
+o’ this software and its associated treasure maps (the “Software”), to plunder and deal
+with it without restriction, includin’ without limit the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and sell
+copies o’ the Software, and to allow other swashbucklers to do the same,
+subject to the followin’ code of the sea:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be hoisted on all
+copies or substantial portions o’ the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+THE SOFTWARE BE PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDIN’ BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, OR NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISIN’ FROM,
+OUT OF, OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS THEREIN.

package/README.md

@@ -0,0 +1,148 @@
+# relay
+
+A lightweight TypeScript framework for building structured Express applications with decorator-based routing.
+
+## Installation
+
+```bash
+npm install @sjoblomtobias/relay
+```
+
+## Usage
+
+### 1. Create a route
+
+Extend the `Route` class and decorate it with `@Public` or `@Private`. Override any of the built-in HTTP method handlers you need.
+
+```ts
+// src/routes/users.ts
+import { Public, Route } from "@sjoblomtobias/relay";
+import type { Request, Response, NextFunction } from "express";
+
+@Public("/users")
+export default class UsersRoute extends Route {
+  protected get(req: Request, res: Response, next: NextFunction): void {
+    res.json([{ id: 1, name: "Alice" }]);
+  }
+
+  protected getById(req: Request, res: Response, next: NextFunction): void {
+    res.json({ id: req.params.id });
+  }
+
+  protected post(req: Request, res: Response, next: NextFunction): void {
+    res.status(201).json(req.body);
+  }
+
+  protected patch(req: Request, res: Response, next: NextFunction): void {
+    res.json({ id: req.params.id, ...req.body });
+  }
+
+  protected delete(req: Request, res: Response, next: NextFunction): void {
+    res.status(204).send();
+  }
+}
+```
+
+### 2. Decorators
+
+| Decorator | Description |
+|-----------|-------------|
+| `@Public(path)` | Registers the route at `path` without authentication |
+| `@Private(path)` | Registers the route at `path`, applies `authMiddleware` if provided |
+| `@Location(path, isPrivate?)` | Base decorator used by `@Public` and `@Private` |
+
+### 3. Register routes and start the server
+
+Import each route class explicitly and pass it to `registerRoutes`. Routes are never loaded implicitly from the filesystem, so the set of registered routes is always visible directly in your code.
+
+```ts
+// src/index.ts
+import { Server } from "@sjoblomtobias/relay";
+import UsersRoute from "./routes/users.js";
+
+const server = new Server(3000);
+
+server.registerRoutes(UsersRoute);
+
+await server.start(undefined, () => {
+  console.log("Ready!");
+});
+```
+
+### 4. Authentication middleware
+
+Pass an Express `RequestHandler` as the second argument to `Server`. It will be applied to all routes decorated with `@Private`. A route decorated with `@Private` throws when it's registered without an `authMiddleware` in place — set it before calling `registerRoutes`.
+
+```ts
+import { Server } from "@sjoblomtobias/relay";
+
+const authMiddleware = (req, res, next) => {
+  if (!req.headers.authorization) return res.status(401).send("Unauthorized");
+  next();
+};
+
+const server = new Server(3000, authMiddleware);
+```
+
+You can also set it separately, as long as it happens before `registerRoutes`:
+
+```ts
+server.setAuthMiddleware(authMiddleware);
+server.registerRoutes(UsersRoute);
+```
+
+## API
+
+### `Server`
+
+| Method | Description |
+|--------|-------------|
+| `new Server(port, authMiddleware?)` | Creates a new server instance |
+| `registerRoutes(...routeClasses)` | Registers one or more route classes. Throws if a `@Private` route is registered before `authMiddleware` is set |
+| `start(before?, after?)` | Starts the server. Awaits optional `before` callback, binds the port, then awaits optional `after` callback |
+| `use(...handlers)` | Adds Express middleware |
+| `getApp()` | Returns the underlying Express app |
+| `setAuthMiddleware(middleware)` | Sets or replaces the authentication middleware. Must be called before `registerRoutes` for any `@Private` route |
+
+### `Route`
+
+Abstract base class. Override any of the following optional methods:
+
+| Method | HTTP method | Path |
+|--------|-------------|------|
+| `get` | GET | `/location` |
+| `getById` | GET | `/location/:id` |
+| `post` | POST | `/location` |
+| `patch` | PATCH | `/location/:id` |
+| `delete` | DELETE | `/location/:id` |
+
+Override `getEndpoints()` to fully customize the endpoint configuration.
+
+## Security
+
+`Server` ships with a couple of safe defaults: the `X-Powered-By` header is disabled, and unhandled route errors are caught and returned as a generic `500` (the error message and stack trace are only included in the response when `NODE_ENV=development`).
+
+Beyond that, relay is intentionally minimal and does not add any hardening middleware for you. Depending on what your app is exposed to, consider adding:
+
+- [`helmet`](https://www.npmjs.com/package/helmet) for standard security headers (CSP, HSTS, etc.)
+- A rate limiter such as [`express-rate-limit`](https://www.npmjs.com/package/express-rate-limit) to slow down brute-force and abuse
+- Body size limits on `express.json()` / `express.urlencoded()` to avoid oversized request payloads
+
+These can be registered like any other Express middleware via `server.use(...)`:
+
+```ts
+import helmet from "helmet";
+import rateLimit from "express-rate-limit";
+import express from "express";
+
+server.use(helmet(), rateLimit({ windowMs: 60_000, limit: 100 }), express.json({ limit: "100kb" }));
+```
+
+Also keep in mind:
+
+- `authMiddleware` must be set (via the `Server` constructor or `setAuthMiddleware`) **before** calling `registerRoutes` — registering a `@Private` route without it throws rather than silently serving the route unprotected.
+- Route classes are only ever registered explicitly via `registerRoutes`; nothing is loaded implicitly from the filesystem, so the set of exposed routes is always visible in your own code.
+
+## License
+
+Pirate

package/dist/index.d.ts

@@ -1,7 +1,2 @@
-/**
- * @author Tobias Sjöblom
- * @since 1.0.0
- * @summary Entry point for the application.
- */
 export * from "./route.js";
 export * from "./server.js";

package/dist/index.js

@@ -1,7 +1,2 @@
-/**
- * @author Tobias Sjöblom
- * @since 1.0.0
- * @summary Entry point for the application.
- */
 export * from "./route.js";
 export * from "./server.js";

package/dist/route.d.ts

@@ -1,8 +1,3 @@
-/**
- * @author Tobias Sjöblom
- * @since 1.0.0
- * @summary Base class for defining routes in an Express application.
- */
 import { Router } from "express";
 import type { Request, Response, NextFunction } from "express";
 /**

package/dist/route.js

@@ -1,8 +1,3 @@
-/**
- * @author Tobias Sjöblom
- * @since 1.0.0
- * @summary Base class for defining routes in an Express application.
- */
 import { Router } from "express";
 /**
  * Decorator to set the base path and authentication requirement for a route class.
@@ -49,15 +44,12 @@ export class Route {
      * Initializes the routes based on the implemented methods in the subclass.
      */
     initializeRoutes() {
+        if (this.isPrivate && !this.authMiddleware) {
+            throw new Error(`Route "${this.location}" is marked private but no authMiddleware was provided. Refusing to register it unprotected.`);
+        }
         this.getEndpoints().forEach(({ path, handler, routerMethod }) => {
             if (typeof handler === "function") {
-                let handlers;
-                if (this.isPrivate && this.authMiddleware) {
-                    handlers = [this.authMiddleware, handler.bind(this)];
-                }
-                else {
-                    handlers = [handler.bind(this)];
-                }
+                const handlers = this.isPrivate && this.authMiddleware ? [this.authMiddleware, handler.bind(this)] : [handler.bind(this)];
                 const fullPath = path ? `${this.location}${path}` : `${this.location}`;
                 routerMethod(fullPath, ...handlers);
             }

package/dist/server.d.ts

@@ -1,27 +1,27 @@
-/**
- * @author Tobias Sjöblom
- * @since 1.0.0
- * @summary Class representing an Express server that dynamically loads routes from a specified directory.
- */
 import express from "express";
+import type { Route } from "./route.js";
 import type { RequestHandler } from "express";
+export type RouteConstructor = new (authMiddleware?: RequestHandler) => Route;
 export declare class Server {
     private port;
-    private routesDirectory;
     private app;
     private authMiddleware?;
     /**
      * Creates an instance of the Server class.
      * @param port The port number on which the server will listen.
-     * @param routesDirectory The directory where route files are located.
      * @param authMiddleware Optional authentication middleware to be used for private routes.
      */
-    constructor(port: number, routesDirectory: string, authMiddleware?: RequestHandler);
+    constructor(port: number, authMiddleware?: RequestHandler);
     /**
-     * Loads all routes from the specified directory.
-     * @returns Promise that resolves when all routes are loaded.
+     * Default error handler. Returns a generic 500 response, only including
+     * the error message and stack trace when NODE_ENV is "development".
      */
-    loadRoutes(): Promise<void>;
+    private readonly errorHandler;
+    /**
+     * Registers one or more route classes with the server.
+     * @param routeClasses - Route classes decorated with @Public or @Private.
+     */
+    registerRoutes(...routeClasses: Array<RouteConstructor>): void;
     /**
      * Adds middleware functions to the Express application.
      * @param handlers - Array of Express request handlers (middleware functions).
@@ -34,7 +34,9 @@ export declare class Server {
     getApp(): express.Express;
     /**
      * Starts the Express server.
+     * @param before Optional callback invoked before the server starts.
+     * @param after Optional callback invoked after the server has started.
      */
-    start(): void;
+    start(before?: () => void | Promise<void>, after?: () => void | Promise<void>): Promise<void>;
     setAuthMiddleware(middleware: RequestHandler): void;
 }

package/dist/server.js

@@ -1,50 +1,55 @@
-/**
- * @author Tobias Sjöblom
- * @since 1.0.0
- * @summary Class representing an Express server that dynamically loads routes from a specified directory.
- */
-import fs from "fs";
-import path from "path";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import express from "express";
 export class Server {
     /**
      * Creates an instance of the Server class.
      * @param port The port number on which the server will listen.
-     * @param routesDirectory The directory where route files are located.
      * @param authMiddleware Optional authentication middleware to be used for private routes.
      */
-    constructor(port, routesDirectory, authMiddleware) {
+    constructor(port, authMiddleware) {
+        /**
+         * Default error handler. Returns a generic 500 response, only including
+         * the error message and stack trace when NODE_ENV is "development".
+         */
+        this.errorHandler = (err, req, res, next) => {
+            if (res.headersSent) {
+                next(err);
+                return;
+            }
+            const isDevelopment = process.env.NODE_ENV === "development";
+            res.status(500).json(Object.assign({ error: "Internal Server Error" }, (isDevelopment && { message: err instanceof Error ? err.message : String(err), stack: err instanceof Error ? err.stack : undefined })));
+        };
         this.port = port;
-        this.routesDirectory = routesDirectory;
         this.app = express();
+        this.app.disable("x-powered-by");
         this.authMiddleware = authMiddleware;
     }
     /**
-     * Loads all routes from the specified directory.
-     * @returns Promise that resolves when all routes are loaded.
+     * Registers one or more route classes with the server.
+     * @param routeClasses - Route classes decorated with @Public or @Private.
      */
-    async loadRoutes() {
-        const routes = path.join(process.cwd(), this.routesDirectory);
-        if (!fs.existsSync(routes)) {
-            console.error(`Routes directory "${routes}" does not exist.`);
-            return;
-        }
-        const files = fs.readdirSync(routes);
-        await Promise.all(files.map(async (file) => {
-            const modulePath = path.join(routes, file);
-            const module = await import(modulePath);
-            const RouteClass = module.default;
-            // Pass authMiddleware to Route constructor
+    registerRoutes(...routeClasses) {
+        routeClasses.forEach((RouteClass) => {
             const routeInstance = new RouteClass(this.authMiddleware);
             this.app.use(routeInstance.router);
-        }));
+        });
     }
     /**
      * Adds middleware functions to the Express application.
      * @param handlers - Array of Express request handlers (middleware functions).
      */
-    async use(...handlers) {
-        this.app.use(handlers);
+    use(...handlers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.app.use(handlers);
+        });
     }
     /**
      * Gets the Express application instance.
@@ -55,10 +60,23 @@ export class Server {
     }
     /**
      * Starts the Express server.
+     * @param before Optional callback invoked before the server starts.
+     * @param after Optional callback invoked after the server has started.
      */
-    start() {
-        this.app.listen(this.port, () => {
-            console.log(`⚡ Server running on port: ${this.port}`);
+    start(before, after) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (before) {
+                yield before();
+            }
+            this.app.use(this.errorHandler);
+            yield new Promise((resolve) => {
+                this.app.listen(this.port, () => {
+                    resolve();
+                });
+            });
+            if (after) {
+                yield after();
+            }
         });
     }
     setAuthMiddleware(middleware) {

package/eslint.config.mts

@@ -48,28 +48,11 @@ export default defineConfig([
 				}
 			],
 			"@typescript-eslint/consistent-type-imports": ["error", { prefer: "type-imports" }],
-			"capitalized-comments": ["error", "always", { ignoreConsecutiveComments: true }],
 			eqeqeq: ["error", "always"],
-			"no-console": "warn",
-			curly: ["error", "all"],
-			"no-restricted-imports": [
-				"error",
-				{
-					patterns: [".*"]
-				}
-			],
 			"import/order": [
 				"error",
 				{
 					groups: ["builtin", "external", "internal", "parent", "sibling", "index", "object", "type"],
-					pathGroups: [
-						{
-							pattern: "@/**",
-							group: "internal",
-							position: "before"
-						}
-					],
-					pathGroupsExcludedImportTypes: ["builtin"],
 					"newlines-between": "never",
 					alphabetize: {
 						order: "asc",
@@ -78,11 +61,5 @@ export default defineConfig([
 				}
 			]
 		}
-	},
-	{
-		files: ["test/**/*.{ts,mts,cts}"],
-		rules: {
-			"no-restricted-imports": "off"
-		}
 	}
 ]);

package/package.json

@@ -1,14 +1,35 @@
 {
 	"name": "@sjoblomtobias/relay",
-	"version": "1.0.0",
+	"version": "2.0.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"scripts": {
-		"build": "tsc && tsc-alias"
+		"build": "tsc",
+		"dev": "tsx --watch test/index.ts",
+		"lint": "eslint src",
+		"format": "prettier --write src"
 	},
 	"author": "Tobias Sjöblom",
-	"license": "MIT",
-	"description": "",
+	"license": "Pirate",
+	"description": "A lightweight TypeScript framework for building structured Express applications with decorator-based routing and automatic route loading.",
+	"keywords": [
+		"express",
+		"typescript",
+		"framework",
+		"decorators",
+		"routing",
+		"rest",
+		"api",
+		"server"
+	],
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/sjoblomtobias/relay.git"
+	},
+	"homepage": "https://github.com/sjoblomtobias/relay#readme",
+	"bugs": {
+		"url": "https://github.com/sjoblomtobias/relay/issues"
+	},
 	"dependencies": {
 		"express": "^5.1.0"
 	},
@@ -25,11 +46,9 @@
 		"eslint-plugin-prettier": "^5.5.4",
 		"globals": "^16.4.0",
 		"jiti": "^2.5.1",
-		"nodemon": "^3.1.10",
 		"prettier": "^3.6.2",
-		"tsc-alias": "^1.8.16",
 		"tsx": "^4.20.5",
 		"typescript": "^5.9.2",
 		"typescript-eslint": "^8.44.0"
 	}
-}
+}

package/src/index.ts

@@ -1,7 +1,2 @@
-/**
- * @author Tobias Sjöblom
- * @since 1.0.0
- * @summary Entry point for the application.
- */
-export * from "@/route";
-export * from "@/server";
+export * from "./route.js";
+export * from "./server.js";

package/src/route.ts

@@ -1,8 +1,3 @@
-/**
- * @author Tobias Sjöblom
- * @since 1.0.0
- * @summary Base class for defining routes in an Express application.
- */
 import { Router } from "express";
 import type { Request, Response, NextFunction } from "express";
 
@@ -66,14 +61,12 @@ export abstract class Route {
 	 * Initializes the routes based on the implemented methods in the subclass.
 	 */
 	protected initializeRoutes() {
+		if (this.isPrivate && !this.authMiddleware) {
+			throw new Error(`Route "${this.location}" is marked private but no authMiddleware was provided. Refusing to register it unprotected.`);
+		}
 		this.getEndpoints().forEach(({ path, handler, routerMethod }) => {
 			if (typeof handler === "function") {
-				let handlers;
-				if (this.isPrivate && this.authMiddleware) {
-					handlers = [this.authMiddleware, handler.bind(this)];
-				} else {
-					handlers = [handler.bind(this)];
-				}
+				const handlers = this.isPrivate && this.authMiddleware ? [this.authMiddleware, handler.bind(this)] : [handler.bind(this)];
 				const fullPath = path ? `${this.location}${path}` : `${this.location}`;
 				routerMethod(fullPath, ...handlers);
 			}

package/src/server.ts

@@ -1,55 +1,51 @@
-/**
- * @author Tobias Sjöblom
- * @since 1.0.0
- * @summary Class representing an Express server that dynamically loads routes from a specified directory.
- */
-
-import fs from "fs";
-import path from "path";
 import express from "express";
-import type { RequestHandler } from "express";
+import type { Route } from "./route.js";
+import type { ErrorRequestHandler, RequestHandler } from "express";
+
+export type RouteConstructor = new (authMiddleware?: RequestHandler) => Route;
 
 export class Server {
 	private port: number;
-	private routesDirectory: string;
 	private app: express.Express;
 	private authMiddleware?: RequestHandler;
 
 	/**
 	 * Creates an instance of the Server class.
 	 * @param port The port number on which the server will listen.
-	 * @param routesDirectory The directory where route files are located.
 	 * @param authMiddleware Optional authentication middleware to be used for private routes.
 	 */
-	constructor(port: number, routesDirectory: string, authMiddleware?: RequestHandler) {
+	constructor(port: number, authMiddleware?: RequestHandler) {
 		this.port = port;
-		this.routesDirectory = routesDirectory;
 		this.app = express();
+		this.app.disable("x-powered-by");
 		this.authMiddleware = authMiddleware;
 	}
 
 	/**
-	 * Loads all routes from the specified directory.
-	 * @returns Promise that resolves when all routes are loaded.
+	 * Default error handler. Returns a generic 500 response, only including
+	 * the error message and stack trace when NODE_ENV is "development".
 	 */
-	public async loadRoutes(): Promise<void> {
-		const routes = path.join(process.cwd(), this.routesDirectory);
-		if (!fs.existsSync(routes)) {
-			console.error(`Routes directory "${routes}" does not exist.`);
+	private readonly errorHandler: ErrorRequestHandler = (err, req, res, next) => {
+		if (res.headersSent) {
+			next(err);
 			return;
 		}
-		const files = fs.readdirSync(routes);
-		await Promise.all(
-			files.map(async (file) => {
-				const modulePath = path.join(routes, file);
-				const module = await import(modulePath);
-				const RouteClass = module.default;
+		const isDevelopment = process.env.NODE_ENV === "development";
+		res.status(500).json({
+			error: "Internal Server Error",
+			...(isDevelopment && { message: err instanceof Error ? err.message : String(err), stack: err instanceof Error ? err.stack : undefined })
+		});
+	};
 
-				// Pass authMiddleware to Route constructor
-				const routeInstance = new RouteClass(this.authMiddleware);
-				this.app.use(routeInstance.router);
-			})
-		);
+	/**
+	 * Registers one or more route classes with the server.
+	 * @param routeClasses - Route classes decorated with @Public or @Private.
+	 */
+	public registerRoutes(...routeClasses: Array<RouteConstructor>): void {
+		routeClasses.forEach((RouteClass) => {
+			const routeInstance = new RouteClass(this.authMiddleware);
+			this.app.use(routeInstance.router);
+		});
 	}
 
 	/**
@@ -70,11 +66,22 @@ export class Server {
 
 	/**
 	 * Starts the Express server.
+	 * @param before Optional callback invoked before the server starts.
+	 * @param after Optional callback invoked after the server has started.
 	 */
-	public start(): void {
-		this.app.listen(this.port, () => {
-			console.log(`⚡ Server running on port: ${this.port}`);
+	public async start(before?: () => void | Promise<void>, after?: () => void | Promise<void>): Promise<void> {
+		if (before) {
+			await before();
+		}
+		this.app.use(this.errorHandler);
+		await new Promise<void>((resolve) => {
+			this.app.listen(this.port, () => {
+				resolve();
+			});
 		});
+		if (after) {
+			await after();
+		}
 	}
 
 	public setAuthMiddleware(middleware: RequestHandler) {

package/test/index.ts

@@ -0,0 +1,15 @@
+import { Server } from "../src/server.js";
+import HelloRoute from "./routes/hello.js";
+
+const server = new Server(3000);
+
+server.registerRoutes(HelloRoute);
+
+server.start(
+	() => {
+		console.log("Before start: registering routes...");
+	},
+	() => {
+		console.log(`⚡ Server running on port: ${server["port"]}`);
+	}
+);

package/test/routes/hello.ts

@@ -0,0 +1,9 @@
+import { Public, Route } from "../../src/route.js";
+import type { Request, Response } from "express";
+
+@Public("/hello")
+export default class HelloRoute extends Route {
+	protected get(req: Request, res: Response): void {
+		res.json({ message: "Hello from relay!" });
+	}
+}

package/tsconfig.json

@@ -1,13 +1,9 @@
 {
 	"compilerOptions": {
-		"baseUrl": ".",
 		"rootDir": "src",
-		"paths": {
-			"@/*": ["./src/*"]
-		},
-		"moduleResolution": "node",
+		"moduleResolution": "bundler",
 		"module": "esnext",
-		"target": "ES2020",
+		"target": "es6",
 		"esModuleInterop": true,
 		"allowSyntheticDefaultImports": true,
 		"strict": true,
@@ -21,9 +17,5 @@
 		"declaration": true
 	},
 	"include": ["src/**/*"],
-	"exclude": ["node_modules", "dist", "src/test"],
-	"tsc-alias": {
-		"resolveFullPaths": true,
-		"verbose": true
-	}
+	"exclude": ["node_modules", "dist", "src/test"]
 }