@stamhoofd/redirecter 2.118.1 → 2.120.0

package/package.json

@@ -1,25 +1,27 @@
 {
     "name": "@stamhoofd/redirecter",
-    "version": "2.118.1",
+    "version": "2.120.0",
+    "type": "module",
     "main": "index.ts",
     "license": "UNLICENCED",
     "scripts": {
         "dev:full": "wait-on ../../shared/middleware/dist/index.js && concurrently -r 'yarn -s build --watch --preserveWatchOutput' \"wait-on ./dist/src/data/belgium.csv && nodemon --quiet --inspect=5858 --watch dist --watch '../../../shared/*/dist/' --watch '../../shared/*/dist/' --ext .ts,.json,.sql,.js --watch .env.json --delay 1000ms --exec 'node --enable-source-maps ./dist/index.js' --signal SIGTERM\"",
-        "build": "rm -rf ./dist/src/migrations && rm -rf ./dist/src/seeds && yarn -s copy-assets && tsc -b",
-        "copy-assets": "rsync --delete --mkpath --exclude='*.ts' --exclude='*.js' -r --checksum ./src/ ./dist/src/",
-        "build:full": "rm -rf ./dist && yarn build",
+        "build": "tsc --build tsconfig.build.json && yarn -s copy-assets",
+        "copy-assets": "rsync --delete --mkpath --exclude='*.ts' --exclude='*.js' --exclude='*.map' -r --checksum ./src/ ./dist/",
+        "build:full": "rm -rf ./dist && rm -f *.tsbuildinfo && yarn -s build",
         "start": "yarn build && node ./dist/index.js",
-        "lint": "eslint"
+        "lint": "eslint",
+        "test": "vitest"
     },
     "devDependencies": {
         "@types/node": "^22"
     },
     "dependencies": {
-        "@simonbackx/simple-endpoints": "1.20.1",
+        "@simonbackx/simple-endpoints": "1.21.0",
         "@simonbackx/simple-logging": "^1.0.1"
     },
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "7461e7ca17f68233be8a8acf1943f2d7882244fd"
+    "gitHead": "f38f79c15ce16b0c8c14743ff3eb61feda5a18d4"
 }

package/src/boot.ts

@@ -1,6 +1,6 @@
 import { Router, RouterServer } from '@simonbackx/simple-endpoints';
-import { Country } from '@stamhoofd/structures';
-
+import { LogMiddleware } from '@stamhoofd/backend-middleware';
+import { Country } from '@stamhoofd/types/Country';
 import { Geolocator } from './classes/Geolocator.js';
 
 process.on('unhandledRejection', (error: Error) => {
@@ -18,20 +18,24 @@ if (new Date().getTimezoneOffset() !== 0) {
 }
 
 const start = async () => {
-    await Geolocator.shared.load(__dirname + '/data/belgium.csv', Country.Belgium);
+    await Geolocator.shared.load(import.meta.dirname + '/data/belgium.csv', Country.Belgium);
 
     // Netherlands not needed, because it is the current default
-    // await Geolocator.shared.load(__dirname+"/data/netherlands.csv", Country.Netherlands)
+    // await Geolocator.shared.load(import.meta.dirname+"/data/netherlands.csv", Country.Netherlands)
 
     console.log('Initialising server...');
     const router = new Router();
-    await router.loadAllEndpoints(__dirname + '/endpoints');
-    await router.loadAllEndpoints(__dirname + '/endpoints/*');
+    await router.loadAllEndpoints(import.meta.dirname + '/endpoints');
+    await router.loadAllEndpoints(import.meta.dirname + '/endpoints/*');
 
     const routerServer = new RouterServer(router);
     routerServer.verbose = false;
     routerServer.listen(STAMHOOFD.PORT ?? 9090);
 
+    // Send the app version along
+    routerServer.addRequestMiddleware(LogMiddleware);
+    routerServer.addResponseMiddleware(LogMiddleware);
+
     const shutdown = async () => {
         console.log('Shutting down...');
         // Disable keep alive

package/src/classes/Geolocator.test.ts

@@ -0,0 +1,34 @@
+import { Country } from '@stamhoofd/types/Country';
+import { Geolocator } from './Geolocator.js';
+
+describe('Geolocator', () => {
+    beforeAll(async () => {
+        await Geolocator.shared.load(import.meta.dirname + '/../data/belgium.csv', Country.Belgium);
+        await Geolocator.shared.load(import.meta.dirname + '/../data/netherlands.csv', Country.Netherlands);
+    });
+
+    test('Returns right', async () => {
+        const country = Geolocator.shared.getCountry('185.115.216.1');
+        expect(country).toEqual(Country.Belgium)
+    });
+
+    test('Returns BE for range defined like - in file', async () => {
+        const country = Geolocator.shared.getCountry('57.233.0.1');
+        expect(country).toEqual(Country.Belgium)
+    });
+
+    test('Returns BE ipv6', async () => {
+        const country = Geolocator.shared.getCountry('2a02:578:04de:b562:3af1:c074:e829:6d30');
+        expect(country).toEqual(Country.Belgium)
+    });
+
+    test('Returns NL ipv6', async () => {
+        const country = Geolocator.shared.getCountry('2a00:8760:c819:6e52:d301:a84f:7b2e:19cd');
+        expect(country).toEqual(Country.Netherlands)
+    });
+
+    test('Returns NL ipv4', async () => {
+        const country = Geolocator.shared.getCountry('37.72.136.125');
+        expect(country).toEqual(Country.Netherlands)
+    });
+});

package/src/classes/Geolocator.ts

@@ -1,30 +1,178 @@
-import { Country } from '@stamhoofd/structures';
+import type { Country } from '@stamhoofd/types/Country';
 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);
+type IPVersion = 4 | 6;
+
+function getIPVersion(ip: string): IPVersion {
+    if (ip.includes(':')) {
+        return 6;
+    }
+
+    if (ip.includes('.')) {
+        return 4;
     }
 
-    return Buffer.from(splitted.map(s => parseInt(s)));
+    throw new Error(`Invalid IP address: ${ip}`);
 }
 
-class IPRange {
-    start: Buffer;
-    end: Buffer; // included
+function ipv4ToBigInt(ip: string): bigint {
+    const parts = ip.split('.');
+
+    if (parts.length !== 4) {
+        throw new Error(`Invalid IPv4 address: ${ip}`);
+    }
+
+    let result = 0n;
+
+    for (const part of parts) {
+        const value = Number(part);
+
+        if (!Number.isInteger(value) || value < 0 || value > 255) {
+            throw new Error(`Invalid IPv4 address: ${ip}`);
+        }
+
+        result = (result << 8n) + BigInt(value);
+    }
+
+    return result;
+}
+
+function ipv6ToBigInt(ip: string): bigint {
+    if (ip.includes(':::')) {
+        throw new Error(`Invalid IPv6 address: ${ip}`);
+    }
+
+    const [leftRaw, rightRaw] = ip.split('::');
+
+    if (ip.split('::').length > 2) {
+        throw new Error(`Invalid IPv6 address: ${ip}`);
+    }
+
+    const left = leftRaw ? leftRaw.split(':') : [];
+    const right = rightRaw ? rightRaw.split(':') : [];
+
+    const missing = 8 - left.length - right.length;
+
+    if (missing < 0) {
+        throw new Error(`Invalid IPv6 address: ${ip}`);
+    }
+
+    const groups: string[] = [
+        ...left,
+        ...Array(missing).fill('0'),
+        ...right,
+    ];
+
+    if (groups.length !== 8) {
+        throw new Error(`Invalid IPv6 address: ${ip}`);
+    }
+
+    let result = 0n;
+
+    for (const group of groups) {
+        if (!/^[0-9a-f]{1,4}$/i.test(group)) {
+            throw new Error(`Invalid IPv6 address: ${ip}`);
+        }
+
+        result = (result << 16n) + BigInt(parseInt(group, 16));
+    }
+
+    return result;
+}
+
+function ipToBigInt(ip: string): { version: IPVersion; value: bigint } {
+    const version = getIPVersion(ip);
+
+    return {
+        version,
+        value: version === 4 ? ipv4ToBigInt(ip) : ipv6ToBigInt(ip),
+    };
+}
+
+function parseRange(range: string): {
+    version: IPVersion;
+    start: bigint;
+    end: bigint;
+} {
+    const trimmed = range.trim();
+
+    if (trimmed.includes('/')) {
+        return parseCIDR(trimmed);
+    }
+
+    const [startRaw, endRaw] = trimmed.split('-');
+
+    if (!startRaw || !endRaw || trimmed.split('-').length !== 2) {
+        throw new Error(`Invalid IP range: ${range}`);
+    }
+
+    const start = ipToBigInt(startRaw.trim());
+    const end = ipToBigInt(endRaw.trim());
+
+    if (start.version !== end.version) {
+        throw new Error(`Invalid mixed IP range: ${range}`);
+    }
+
+    if (start.value > end.value) {
+        throw new Error(`Invalid reversed IP range: ${range}`);
+    }
+
+    return {
+        version: start.version,
+        start: start.value,
+        end: end.value,
+    };
+}
+
+function parseCIDR(cidr: string): {
+    version: IPVersion;
+    start: bigint;
+    end: bigint;
+} {
+    const [ip, prefixRaw] = cidr.trim().split('/');
+
+    if (!ip || prefixRaw === undefined) {
+        throw new Error(`Invalid CIDR range: ${cidr}`);
+    }
+
+    const { version, value } = ipToBigInt(ip);
+    const bits = version === 4 ? 32 : 128;
+    const prefix = Number(prefixRaw);
 
+    if (!Number.isInteger(prefix) || prefix < 0 || prefix > bits) {
+        throw new Error(`Invalid CIDR prefix: ${cidr}`);
+    }
+
+    const hostBits = BigInt(bits - prefix);
+    const size = 1n << hostBits;
+    const start = (value / size) * size;
+    const end = start + size - 1n;
+
+    return {
+        version,
+        start,
+        end,
+    };
+}
+
+class IPRange {
+    version: IPVersion;
+    start: bigint;
+    end: bigint;
     carrier: string;
 
-    constructor(start: string, end: string, carrier: string) {
-        this.start = fromIP(start);
-        this.end = fromIP(end);
+    constructor(cidr: string, carrier = '') {
+        const parsed = parseRange(cidr);
+
+        this.version = parsed.version;
+        this.start = parsed.start;
+        this.end = parsed.end;
         this.carrier = carrier;
     }
 
-    includes(ip: Buffer): boolean {
-        return this.start.compare(ip) <= 0 && this.end.compare(ip) >= 0;
+    includes(version: IPVersion, ip: bigint): boolean {
+        return this.version === version && this.start <= ip && ip <= this.end;
     }
 }
 
@@ -38,43 +186,33 @@ export class Geolocator {
             input: fs.createReadStream(file, { encoding: 'utf-8' }),
         });
 
-        const range = this.ranges.get(country) ?? [];
-        this.ranges.set(country, range);
+        const ranges = this.ranges.get(country) ?? [];
+        this.ranges.set(country, ranges);
 
-        for await (const line of lineReader) {
-            const splitted = line.split(',');
-            if (splitted.length < 2) {
-                console.error(`Failed to parse line: ${line}`);
+        for await (const rawLine of lineReader) {
+            const line = rawLine.trim();
+
+            if (!line || line.startsWith('#')) {
                 continue;
             }
-            const from = splitted[0];
-            const to = splitted[1];
 
-            range.push(new IPRange(from, to, splitted[4] ?? ''));
+            try {
+                ranges.push(new IPRange(line));
+            } catch (error) {
+                console.error(`Failed to parse line: ${line}`, error);
+            }
         }
     }
 
     getCountry(ip: string): Country | undefined {
-        const parsed = fromIP(ip);
+        const parsed = ipToBigInt(ip);
 
         for (const [country, ranges] of this.ranges) {
             for (const range of ranges) {
-                if (range.includes(parsed)) {
+                if (range.includes(parsed.version, parsed.value)) {
                     return country;
                 }
             }
         }
     }
-
-    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 };
-                }
-            }
-        }
-    }
 }