@stamhoofd/redirecter 2.39.1 → 2.40.1

package/eslint.config.mjs

@@ -0,0 +1,5 @@
+import stamhoofdEslint from 'eslint-plugin-stamhoofd';
+
+export default [
+    ...stamhoofdEslint.configs.backend,
+];

package/index.ts

@@ -1,52 +1,55 @@
-require('@stamhoofd/backend-env').load({ service: "redirecter" })
-import { Router, RouterServer } from "@simonbackx/simple-endpoints";
-import { Country } from "@stamhoofd/structures";
+import backendEnv from '@stamhoofd/backend-env';
+backendEnv.load({ service: 'redirecter' });
 
-import { Geolocator } from "./src/classes/Geolocator";
+import { Router, RouterServer } from '@simonbackx/simple-endpoints';
+import { Country } from '@stamhoofd/structures';
 
-process.on("unhandledRejection", (error: Error) => {
-    console.error("unhandledRejection");
+import { Geolocator } from './src/classes/Geolocator';
+
+process.on('unhandledRejection', (error: Error) => {
+    console.error('unhandledRejection');
     console.error(error.message, error.stack);
     process.exit(1);
 });
 
 // Set timezone!
-process.env.TZ = "UTC";
+process.env.TZ = 'UTC';
 
 // Quick check
-if (new Date().getTimezoneOffset() != 0) {
-    throw new Error("Process should always run in UTC timezone");
+if (new Date().getTimezoneOffset() !== 0) {
+    throw new Error('Process should always run in UTC timezone');
 }
 
-const start = async () => {    
-    await Geolocator.shared.load(__dirname+"/src/data/belgium.csv", Country.Belgium)
+const start = async () => {
+    await Geolocator.shared.load(__dirname + '/src/data/belgium.csv', Country.Belgium);
 
     // Netherlands not needed, because it is the current default
-    //await Geolocator.shared.load(__dirname+"/src/data/netherlands.csv", Country.Netherlands)
+    // await Geolocator.shared.load(__dirname+"/src/data/netherlands.csv", Country.Netherlands)
 
-    console.log("Initialising server...")
+    console.log('Initialising server...');
     const router = new Router();
-    await router.loadAllEndpoints(__dirname + "/src/endpoints");
-    await router.loadAllEndpoints(__dirname + "/src/endpoints/*");
+    await router.loadAllEndpoints(__dirname + '/src/endpoints');
+    await router.loadAllEndpoints(__dirname + '/src/endpoints/*');
 
     const routerServer = new RouterServer(router);
-    routerServer.verbose = false
+    routerServer.verbose = false;
     routerServer.listen(STAMHOOFD.PORT ?? 9090);
 
     const shutdown = async () => {
-        console.log("Shutting down...")
+        console.log('Shutting down...');
         // Disable keep alive
-        routerServer.defaultHeaders = Object.assign(routerServer.defaultHeaders, { 'Connection': 'close' })
+        routerServer.defaultHeaders = Object.assign(routerServer.defaultHeaders, { Connection: 'close' });
         if (routerServer.server) {
             routerServer.server.headersTimeout = 5000;
             routerServer.server.keepAliveTimeout = 1;
         }
 
         try {
-            await routerServer.close()
-            console.log("HTTP server stopped");
-        } catch (err) {
-            console.error("Failed to stop HTTP server:");
+            await routerServer.close();
+            console.log('HTTP server stopped');
+        }
+        catch (err) {
+            console.error('Failed to stop HTTP server:');
             console.error(err);
         }
 
@@ -54,24 +57,24 @@ const start = async () => {
         process.exit(0);
     };
 
-    process.on("SIGTERM", () => {
-        console.info("SIGTERM signal received.");
+    process.on('SIGTERM', () => {
+        console.info('SIGTERM signal received.');
         shutdown().catch((e) => {
-            console.error(e)
+            console.error(e);
             process.exit(1);
         });
     });
 
-    process.on("SIGINT", () => {
-        console.info("SIGINT signal received.");
+    process.on('SIGINT', () => {
+        console.info('SIGINT signal received.');
         shutdown().catch((e) => {
-            console.error(e)
+            console.error(e);
             process.exit(1);
         });
     });
 };
 
-start().catch(error => {
-    console.error("unhandledRejection", error);
+start().catch((error) => {
+    console.error('unhandledRejection', error);
     process.exit(1);
 });

package/package.json

@@ -1,13 +1,13 @@
 {
     "name": "@stamhoofd/redirecter",
-    "version": "2.39.1",
+    "version": "2.40.1",
     "main": "index.ts",
     "license": "UNLICENCED",
     "scripts": {
         "build": "rm -rf ./dist/src/data && tsc -b && mkdir -p ./dist/src/data && cp ./src/data/* ./dist/src/data",
         "build:full": "rm -rf ./dist && yarn build",
         "start": "yarn build && node ./dist/index.js",
-        "lint": "eslint . --ext .js,.jsx,.ts,.tsx"
+        "lint": "eslint"
     },
     "devDependencies": {
         "@types/node": "^20.12"
@@ -16,5 +16,5 @@
         "@simonbackx/simple-endpoints": "1.14.0",
         "@simonbackx/simple-logging": "^1.0.1"
     },
-    "gitHead": "13df02459d27104c9bf92ff3d905920cf81276c4"
+    "gitHead": "31eb933097eb608655f755de9df912c21a420963"
 }

package/src/classes/Geolocator.ts

@@ -1,81 +1,81 @@
-import { Country } from "@stamhoofd/structures";
-import fs from "fs";
-import readline from "readline";
+import { Country } from '@stamhoofd/structures';
+import fs from 'fs';
+import readline from 'readline';
 
 function fromIP(ip: string): Buffer {
-    const splitted = ip.split(".")
-    if (splitted.length != 4) {
-        throw new Error("Invalid ipv4 address " + ip)
+    const splitted = ip.split('.');
+    if (splitted.length !== 4) {
+        throw new Error('Invalid ipv4 address ' + ip);
     }
 
-    return Buffer.from(splitted.map(s => parseInt(s)))
+    return Buffer.from(splitted.map(s => parseInt(s)));
 }
 
 class IPRange {
-    start: Buffer
-    end: Buffer // included
+    start: Buffer;
+    end: Buffer; // included
 
-    carrier: string
+    carrier: string;
 
     constructor(start: string, end: string, carrier: string) {
-        this.start = fromIP(start)
-        this.end = fromIP(end)
-        this.carrier = carrier
+        this.start = fromIP(start);
+        this.end = fromIP(end);
+        this.carrier = carrier;
     }
 
     includes(ip: Buffer): boolean {
-        return this.start.compare(ip) <= 0 && this.end.compare(ip) >= 0
+        return this.start.compare(ip) <= 0 && this.end.compare(ip) >= 0;
     }
 }
 
 export class Geolocator {
-    static shared = new Geolocator()
+    static shared = new Geolocator();
 
-    ranges: Map<Country, IPRange[]> = new Map()
+    ranges: Map<Country, IPRange[]> = new Map();
 
     async load(file: string, country: Country) {
         const lineReader = readline.createInterface({
-            input: fs.createReadStream(file, { encoding: "utf-8" })
+            input: fs.createReadStream(file, { encoding: 'utf-8' }),
         });
 
-        const range = this.ranges.get(country) ?? []
-        this.ranges.set(country, range)
+        const range = this.ranges.get(country) ?? [];
+        this.ranges.set(country, range);
 
         for await (const line of lineReader) {
-            const splitted = line.split(",")
+            const splitted = line.split(',');
             if (splitted.length < 2) {
                 console.error(`Failed to parse line: ${line}`);
                 continue;
             }
-            const from = splitted[0]
-            const to = splitted[1]
+            const from = splitted[0];
+            const to = splitted[1];
 
-            console.log("From ", from, "to", to)
-            range.push(new IPRange(from, to, splitted[4] ?? ""))
+            console.log('From ', from, 'to', to);
+            range.push(new IPRange(from, to, splitted[4] ?? ''));
         }
     }
 
     getCountry(ip: string): Country | undefined {
-        const parsed = fromIP(ip)
+        const parsed = fromIP(ip);
 
         for (const [country, ranges] of this.ranges) {
             for (const range of ranges) {
                 if (range.includes(parsed)) {
-                    return country
+                    return country;
                 }
             }
         }
     }
 
-    getInfo(ip: string): { country: Country, carrier: string } | undefined {
-        const parsed = fromIP(ip)
+    getInfo(ip: string): { country: Country; carrier: string } | undefined {
+        const parsed = fromIP(ip);
 
         for (const [country, ranges] of this.ranges) {
             for (const range of ranges) {
                 if (range.includes(parsed)) {
-                    return {country, carrier: range.carrier}
+                    return { country, carrier: range.carrier };
                 }
             }
         }
     }
-}
+}

package/src/endpoints/RedirectEndpoint.ts

@@ -1,58 +1,55 @@
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints'
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Country } from '@stamhoofd/structures';
-import { URL } from "url";
 
 import { Geolocator } from '../classes/Geolocator';
 
 type Params = Record<string, never>;
-type Body = undefined
-type Query = undefined
-type ResponseBody = string
+type Body = undefined;
+type Query = undefined;
+type ResponseBody = string;
 
 function getRequestIP(request: Request): string {
     let ipAddress = request.request?.socket.remoteAddress;
-    if (request.headers["x-real-ip"] && typeof request.headers["x-real-ip"] == "string" && (ipAddress == "127.0.0.1" || ipAddress == "0.0.0.0")) {
-        ipAddress = request.headers["x-real-ip"];
+    if (request.headers['x-real-ip'] && typeof request.headers['x-real-ip'] === 'string' && (ipAddress === '127.0.0.1' || ipAddress === '0.0.0.0')) {
+        ipAddress = request.headers['x-real-ip'];
     }
     if (!ipAddress) {
         ipAddress = '?';
     }
 
-    return ipAddress.split(":", 2)[0]
+    return ipAddress.split(':', 2)[0];
 }
 
-
-export class RedirectEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {    
-    protected doesMatch(request: Request): [true, Params] | [false] {
-        return [true, {}]
+export class RedirectEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    protected doesMatch(_request: Request): [true, Params] | [false] {
+        return [true, {}];
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const ip = getRequestIP(request.request)
-
-        const country = Geolocator.shared.getCountry(ip)
+        const ip = getRequestIP(request.request);
 
-        const path = request.request.request?.url ?? ""
+        const country = Geolocator.shared.getCountry(ip);
 
+        const path = request.request.request?.url ?? '';
 
         if (country === Country.Belgium) {
-            const url = "https://www.stamhoofd.be"+path
-            const response = new Response("Doorverwijzen naar "+url)
-            response.status = 302
-            response.headers["Location"] = url
+            const url = 'https://www.stamhoofd.be' + path;
+            const response = new Response('Doorverwijzen naar ' + url);
+            response.status = 302;
+            response.headers['Location'] = url;
 
             // Prevent encoding and version requirement
-            response.headers["Content-Type"] = "text/html"
+            response.headers['Content-Type'] = 'text/html';
             return Promise.resolve(response);
         }
 
-        const url = "https://www.stamhoofd.nl"+path
-        const response = new Response("Doorverwijzen naar "+url)
-        response.status = 302
-        response.headers["Location"] = url
+        const url = 'https://www.stamhoofd.nl' + path;
+        const response = new Response('Doorverwijzen naar ' + url);
+        response.status = 302;
+        response.headers['Location'] = url;
 
         // Prevent encoding and version requirement
-        response.headers["Content-Type"] = "text/html"
+        response.headers['Content-Type'] = 'text/html';
         return Promise.resolve(response);
     }
 }

package/stamhoofd.d.ts

@@ -1,15 +1,14 @@
-
 export {};
 
 /**
- * Stamhoofd uses a global variable to store some configurations. We don't use process.env because we can only store 
- * strings into those files. And we need objects for our localized domains (different domains for each locale). 
+ * Stamhoofd uses a global variable to store some configurations. We don't use process.env because we can only store
+ * strings into those files. And we need objects for our localized domains (different domains for each locale).
  * Having to encode and decode those values would be inefficient.
- * 
- * So we use our own global configuration variable: STAMHOOFD. Available everywhere and contains 
- * other information depending on the environment (frontend/backend/shared). TypeScript will 
+ *
+ * So we use our own global configuration variable: STAMHOOFD. Available everywhere and contains
+ * other information depending on the environment (frontend/backend/shared). TypeScript will
  * always suggest the possible keys.
  */
 declare global {
-    const STAMHOOFD: RedirecterEnvironment
-}
+    const STAMHOOFD: RedirecterEnvironment;
+}

package/.eslintrc.js

@@ -1,61 +0,0 @@
-module.exports = {
-    root: true,
-    ignorePatterns: ["dist/", "node_modules/"],
-    parserOptions: {
-        "ecmaVersion": 2017
-    },
-    env: {
-        "es6": true,
-        "node": true,
-    },
-    extends: [
-        "eslint:recommended",
-    ],
-    plugins: [],
-    rules: {
-        "no-console": "off",
-        "no-debugger": process.env.NODE_ENV === "production" ? "error" : "off",
-        "sort-imports": "off",
-        "import/order": "off"
-    },
-    overrides: [
-        {
-            // Rules for TypeScript and vue
-            files: ["*.ts"],
-            parser: "@typescript-eslint/parser",
-            parserOptions: {
-                project: ["./tsconfig.json"]
-            },
-            plugins: ["@typescript-eslint", "jest"],
-            extends: [
-                "eslint:recommended",
-                "plugin:@typescript-eslint/eslint-recommended",
-                "plugin:@typescript-eslint/recommended",
-                "plugin:@typescript-eslint/recommended-requiring-type-checking",
-                "plugin:jest/recommended",
-            ],
-            rules: {
-                "no-console": "off",
-                "no-debugger": process.env.NODE_ENV === "production" ? "error" : "off",
-                "sort-imports": "off",
-                "import/order": "off",
-                "@typescript-eslint/explicit-function-return-type": "off",
-                "@typescript-eslint/no-explicit-any": "off",
-                "@typescript-eslint/no-unused-vars": ["warn", { argsIgnorePattern: "^_" }],
-                "@typescript-eslint/no-namespace": "off",
-                "@typescript-eslint/no-floating-promises": "error",
-                "@typescript-eslint/no-misused-promises": "error",
-                "@typescript-eslint/prefer-for-of": "warn",
-                "@typescript-eslint/no-empty-interface": "off", // It is convenient to have placeholder interfaces
-                "@typescript-eslint/no-this-alias": "off", // No idea why we need this. This breaks code that is just fine. Prohibit the use of function() instead of this rule
-                "@typescript-eslint/unbound-method": "off", // Methods are automatically bound in vue, it would break removeEventListeners if we bound it every time unless we save every method in variables again...
-                "@typescript-eslint/no-unsafe-assignment": "off", // This is impossible to use with dependencies that don't have types yet, such as tiptap
-                "@typescript-eslint/no-unsafe-return": "off", // This is impossible to use with dependencies that don't have types yet, such as tiptap
-                "@typescript-eslint/no-unsafe-call": "off", // This is impossible to use with dependencies that don't have types yet, such as tiptap
-                "@typescript-eslint/no-unsafe-member-access": "off", // This is impossible to use with dependencies that don't have types yet, such as tiptap
-                "@typescript-eslint/restrict-plus-operands": "off", // bullshit one
-                "@typescript-eslint/explicit-module-boundary-types": "off",
-            },
-        }
-    ]
-};