country-linkify 24.482.11825

package/.dockerignore

@@ -0,0 +1,12 @@
+.DS_Store
+.prettierignore
+.github/
+.history/
+.vscode/
+coverage/
+docs/
+node_modules/
+Makefile
+settings.local.json
+settings.secret.json
+*.log

package/.github/FUNDING.yml

@@ -0,0 +1 @@
+github: igoramadas

package/Dockerfile

@@ -0,0 +1,23 @@
+# BUILDER
+FROM node:22-alpine AS cl-builder
+ENV NODE_ENV=development
+WORKDIR /app
+COPY . .
+RUN npm install && ./node_modules/.bin/tsc
+
+# DEPENDENCIES
+FROM node:22-alpine AS cl-dependencies
+ENV NODE_ENV=production
+WORKDIR /app
+COPY . .
+RUN npm install --production
+
+# FINAL IMAGE
+FROM node:22-alpine AS cl-final
+ENV NODE_ENV=production
+WORKDIR /app
+COPY . .
+COPY --from=cl-dependencies ./app/node_modules ./node_modules
+COPY --from=cl-builder ./app/lib ./lib
+
+CMD ["npm", "start"]

package/README.md

@@ -0,0 +1,75 @@
+# Country Linkify
+
+Simple Node.js library / service to redirect links based on the client's country and link ID.
+
+## Link definitions
+
+All links should be defined in .json files under the [/links](https://github.com/igoramadas/country-linkify/tree/master/links) folder (or another folder, if you change the `settings.links.path` key). Each file represents a `source`, for example, a specific website or category of links.
+
+Each key inside the JSON specs represents a link ID, and the target URLs by country. If a key gets a single string as its value, this will be the URL valid for any country.
+
+There are also 2 standard keys, prefixed with an underscore:
+
+-   **\_default**: the default target URL(s) for that source.
+-   **\_search**: URL for the search page of the source, must have a `{{query}}` tag defined
+
+A sample definition for "Amazon":
+
+```json
+{
+    "_default": {
+        "de": "https://www.amazon.de/",
+        "us": "https://www.amazon.com/",
+        "uk": "https://www.amazon.co.uk/"
+    },
+    "_search": {
+        "us": "https://www.amazon.com/s?k={{query}}"
+    },
+    "deals": {
+        "de": "https://www.amazon.de/-/en/deals",
+        "us": "https://www.amazon.com/gp/goldbox",
+        "uk": "https://www.amazon.co.uk/gp/deals"
+    },
+    "help": "https://www.amazon.com/gp/help/customer/display.html"
+}
+```
+
+And a second file for "AliExpress":
+
+```json
+{
+    "_default": "https://aliexpress.com",
+    "_search": {
+        "de": "https://de.aliexpress.com/w/{{query}}.html"
+    },
+    "deals": {
+        "de": "https://www.aliexpress.com/sp/campaign/wow/gcp-plus/300000444/njcQZ4CkBb"
+    }
+}
+```
+
+With the samples above, a user from Germany (de) will get redirected to the following target URLs:
+
+-   **/l/amazon**: https://www.amazon.de/
+-   **/l/amazon-help**: https://www.amazon.com/gp/help/customer/display.html
+-   **/l/amazon-deals**: https://www.amazon.de/-/en/deals
+-   **/l/deals**: https://www.amazon.de/-/en/deals or https://www.aliexpress.com/sp/campaign/wow/gcp-plus/300000444/njcQZ4CkBb
+-   **/s/some-item**: https://de.aliexpress.com/w/some-item.html
+
+And the results for someone from US:
+
+-   **/l/amazon**: https://www.amazon.com/
+-   **/l/amazon-help**: https://www.amazon.com/gp/help/customer/display.html
+-   **/l/amazon-deals**: https://www.amazon.com/gp/goldbox
+-   **/s/some-item**: "https://www.amazon.com/s?k=some+item"
+
+## Settings
+
+This tool is using the [SetMeUp](https://github.com/igoramadas/setmeup) module to handle its settings, so for detailed info please check its [docs](https://setmeup.devv.com).
+
+-   **settings.json** - settings shared by all environments, targeting production by default
+-   **settings.development.json** - development settings, mostly when running on your dev machine
+-   **settings.production.json** - production-only settings, except credentials and secrets (optional)
+-   **settings.local.json** - private local-only settings, excluded from the GIT repo
+
+Settings are self explanatory, please open each file to check the available options.

package/assets/404.html

@@ -0,0 +1,17 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>Devv</title>
+        <meta name="description" content="Free software, power to the people! Node.js Javascript TypeScript Docker GCP." />
+        <meta name="viewport" content="height=device-height, width=device-width, initial-scale=1" />
+        <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Crete+Round&display=swap" />
+        <link rel="stylesheet" href="/styles.css" />
+    </head>
+    <body>
+        <div class="wrapper">
+            <h1>Devv</h1>
+            <p class="margin-top">We could not find the destination you were looking for. Perhaps our affiliate links?</p>
+            <div class="margin-top logos">${logos}</div>
+        </div>
+    </body>
+</html>

package/assets/redir.html

@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <title>Redirecting from ${from} to ${target}</title>
+        <meta http-equiv="refresh" content="2;URL='${url}'" />
+        <meta name="viewport" content="height=device-height, width=device-width, initial-scale=1" />
+        <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Crete+Round&display=swap" />
+        <link rel="stylesheet" href="/styles.css" />
+    </head>
+    <body>
+        <div class="wrapper">
+            <h2>Redirecting from ${from}</h2>
+            <p class="margin-top">You'll be redirected to an affiliate link in a few seconds...</p>
+            <div class="redir-logo">
+                <a href="${url}"><img src="/images/${logo}.png" class="logo" /></a>
+            </div>
+        </div>
+        <script type="text/javascript">
+            const redirDelay = () => (window.location.href = "${url}")
+            setTimeout(redirDelay, 2000)
+        </script>
+    </body>
+</html>

package/assets/robots.txt

@@ -0,0 +1,2 @@
+User-agent: *
+Disallow: /

package/assets/styles.css

@@ -0,0 +1,49 @@
+html {
+    background: rgb(255, 255, 255);
+    height: 100%;
+}
+
+body {
+    background: linear-gradient(180deg, rgba(25, 25, 25, 1) 0%, rgba(5, 5, 5, 1) 5%, rgba(0, 0, 0, 1) 100%);
+    color: rgb(255, 255, 255);
+    font-family: "Crete Round", Arial, Helvetica, sans-serif;
+    margin: auto;
+    min-height: 100%;
+    text-align: center;
+    width: auto;
+}
+
+h1 {
+    font-size: 9em;
+    margin: 0;
+}
+
+.wrapper {
+    padding-top: 20px;
+}
+
+.margin-top {
+    margin-top: 20px;
+}
+
+.logos {
+    background: rgb(220, 220, 220);
+    border-radius: 20px;
+    margin: auto;
+    max-width: 960px;
+    padding: 5px 0 40px 0;
+}
+
+.logos img {
+    margin: 5px 20px 5px 20px;
+    max-width: 260px;
+    vertical-align: middle;
+}
+
+.redir-logo {
+    margin-top: 50px;
+}
+
+.redir-logo img {
+    max-width: 260px;
+}

package/lib/countrymanager.d.ts

@@ -0,0 +1,13 @@
+export declare class CountryManager {
+    private constructor();
+    private static _instance;
+    static get Instance(): CountryManager;
+    aliases: {
+        [id: string]: string;
+    };
+    init: () => Promise<void>;
+    load: () => Promise<void>;
+    getForIP: (ip: string) => Promise<string>;
+}
+declare const _default: CountryManager;
+export default _default;

package/lib/countrymanager.js

@@ -0,0 +1,93 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CountryManager = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const bent = require("bent");
+const bitecache_1 = __importDefault(require("bitecache"));
+const anyhow_1 = __importDefault(require("anyhow"));
+let settings;
+class CountryManager {
+    constructor() { }
+    static _instance;
+    static get Instance() {
+        return this._instance || (this._instance = new this());
+    }
+    aliases = {};
+    init = async () => {
+        settings = require("setmeup").settings.countryLinkify;
+        try {
+            await this.load();
+            bitecache_1.default.setup(settings.cacheName, settings.country.cacheDuration);
+        }
+        catch (ex) {
+            anyhow_1.default.error("CountryManager.init", "Failed to init", ex);
+            throw ex;
+        }
+    };
+    load = async () => {
+        const countryAliases = Object.entries(settings.country);
+        let code;
+        let aliases;
+        for ([code, aliases] of countryAliases) {
+            if (code == "cacheDuration" || code == "default")
+                continue;
+            code = code.toLowerCase();
+            if (lodash_1.default.isString(aliases)) {
+                aliases = [aliases];
+            }
+            anyhow_1.default.debug("Country.load", `Country ${code} aliases: ${aliases.join(", ")}`);
+            for (let alias of aliases) {
+                this.aliases[alias] = code;
+            }
+        }
+    };
+    getForIP = async (ip) => {
+        if (!ip) {
+            anyhow_1.default.warn("CountryManager.getForIP", "Missing IP address");
+            return null;
+        }
+        const cached = bitecache_1.default.get(settings.cacheName, ip);
+        if (cached) {
+            anyhow_1.default.debug("CountryManager.getForIP", ip, "From cache");
+            return cached;
+        }
+        let apiHost;
+        anyhow_1.default.debug("CountryManager.getForIP", ip);
+        try {
+            apiHost = "geojs.io";
+            const ipUrl = `https://get.geojs.io/v1/ip/country/${ip}.json`;
+            const apiGet = bent(ipUrl, "GET", "json");
+            const ipData = await apiGet();
+            if (ipData && ipData.country) {
+                anyhow_1.default.debug("CountryManager.getForIP", ip, ipData.country, `Via ${apiHost}`);
+                const result = ipData.country.toLowerCase();
+                bitecache_1.default.set(settings.cacheName, ip, result);
+                return result;
+            }
+        }
+        catch (ex) {
+            anyhow_1.default.error("CountryManager.getForIP", ip, apiHost, ex);
+        }
+        try {
+            apiHost = "ip-api.com";
+            const ipUrl = `http://ip-api.com/json/${ip}`;
+            const apiGet = bent(ipUrl, "GET", "json");
+            const ipData = await apiGet();
+            if (ipData && ipData.countryCode) {
+                anyhow_1.default.debug("CountryManager.getForIP", ip, ipData.countryCode, `Via ${apiHost}`);
+                const result = ipData.countryCode.toLowerCase();
+                bitecache_1.default.set(settings.cacheName, ip, result);
+                return result;
+            }
+        }
+        catch (ex) {
+            anyhow_1.default.error("CountryManager.getForIP", ip, apiHost, ex);
+        }
+        return null;
+    };
+}
+exports.CountryManager = CountryManager;
+exports.default = CountryManager.Instance;

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+import express = require("express");
+declare const startup: (app?: express.Express) => Promise<never>;
+export default startup;

package/lib/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const anyhow_1 = __importDefault(require("anyhow"));
+const setmeup_1 = __importDefault(require("setmeup"));
+const countrymanager_1 = __importDefault(require("./countrymanager"));
+const linkmanager_1 = __importDefault(require("./linkmanager"));
+const server_1 = __importDefault(require("./server"));
+const startup = async (app) => {
+    anyhow_1.default.info("CountryLinkify.startup", `PID ${process.pid}`);
+    try {
+        if (!setmeup_1.default.settings.countryLinkify) {
+            setmeup_1.default.load();
+            setmeup_1.default.loadFromEnv();
+            setmeup_1.default.load("settings.local.json");
+        }
+        await countrymanager_1.default.init();
+        await linkmanager_1.default.init();
+        await server_1.default.init(app);
+    }
+    catch (ex) {
+        anyhow_1.default.warn("CountryLinkify.startup", ex);
+        return process.exit();
+    }
+};
+exports.default = startup;

package/lib/linkmanager.d.ts

@@ -0,0 +1,20 @@
+import { Link, TargetURL } from "./types";
+export declare class LinkManager {
+    private constructor();
+    private static _instance;
+    static get Instance(): LinkManager;
+    private watchers;
+    sources: string[];
+    links: {
+        [id: string]: Link;
+    };
+    aliases: {
+        [alias: string]: string;
+    };
+    init: () => Promise<void>;
+    load: (reset?: boolean) => Promise<void>;
+    loadFile: (filepath: string) => Promise<void>;
+    urlFor: (id: string, country: string, sources?: string[], search?: boolean) => TargetURL;
+}
+declare const _default: LinkManager;
+export default _default;

package/lib/linkmanager.js

@@ -0,0 +1,203 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinkManager = void 0;
+const utils_1 = require("./utils");
+const countrymanager_1 = __importDefault(require("./countrymanager"));
+const lodash_1 = __importDefault(require("lodash"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const anyhow_1 = __importDefault(require("anyhow"));
+let settings;
+class LinkManager {
+    constructor() { }
+    static _instance;
+    static get Instance() {
+        return this._instance || (this._instance = new this());
+    }
+    watchers = [];
+    sources = [];
+    links = {};
+    aliases = {};
+    init = async () => {
+        settings = require("setmeup").settings.countryLinkify;
+        try {
+            await this.load();
+        }
+        catch (ex) {
+            anyhow_1.default.error("LinkManager.init", "Failed to init", ex);
+            throw ex;
+        }
+    };
+    load = async (reset) => {
+        try {
+            const directory = settings.links.path.substring(0, 1) == "/" ? settings.links.path : path_1.default.join(process.cwd(), settings.links.path);
+            if (!fs_1.default.existsSync(directory)) {
+                anyhow_1.default.warn("LinkManager.load", `Directory ${directory} not found, no links were loaded`);
+                return;
+            }
+            const files = fs_1.default.readdirSync(directory);
+            if (reset) {
+                const count = Object.keys(this.links).length;
+                anyhow_1.default.info("LinkManager.load", "Reset", `Cleared ${count} links`);
+                for (let watcher of this.watchers) {
+                    try {
+                        watcher.close();
+                    }
+                    catch (ex) {
+                        anyhow_1.default.error("LinkManager.load.reset", ex);
+                    }
+                }
+                this.links = {};
+                this.watchers = [];
+            }
+            anyhow_1.default.debug("LinkManager.load", `Will load ${files.length} file(s)`);
+            for (let filename of files) {
+                try {
+                    const filepath = path_1.default.join(directory, filename);
+                    await this.loadFile(filepath);
+                    if (settings.links.autoReload) {
+                        const watcher = fs_1.default.watch(filepath, async (e, changedfile) => {
+                            if (changedfile && e == "change") {
+                                const basename = path_1.default.basename(changedfile, ".json");
+                                try {
+                                    changedfile = path_1.default.join(directory, changedfile);
+                                    anyhow_1.default.info("LinkManager.load.watch", basename, "Reloading");
+                                    await this.loadFile(changedfile);
+                                }
+                                catch (ex) {
+                                    anyhow_1.default.warn("LinkManager.load.watch", basename, "Failed to reload");
+                                }
+                            }
+                        });
+                        this.watchers.push(watcher);
+                    }
+                }
+                catch (fileEx) {
+                    anyhow_1.default.warn("LinkManager.load", filename, "Failed to load");
+                }
+            }
+            const aEntries = Object.entries(settings.links.aliases);
+            if (aEntries.length > 0) {
+                aEntries.forEach((e) => e[1].forEach((a) => {
+                    this.aliases[a] = e[0];
+                    if (settings.links.autoPlural) {
+                        this.aliases[`${a}s`] = e[0];
+                    }
+                }));
+                anyhow_1.default.info("LinkManager.load", `${Object.keys(this.aliases).length} link aliases (${settings.links.autoPlural ? "with" : "no"} plurals)`);
+            }
+        }
+        catch (ex) {
+            anyhow_1.default.error("LinkManager.load", ex);
+        }
+    };
+    loadFile = async (filepath) => {
+        try {
+            const source = path_1.default.basename(filepath, ".json").toLowerCase();
+            const data = fs_1.default.readFileSync(filepath, { encoding: settings.encoding });
+            const entries = Object.entries(JSON.parse(data));
+            if (!this.sources.includes(source)) {
+                this.sources.push(source);
+            }
+            for (let [id, countryUrls] of entries) {
+                id = id.toLowerCase();
+                if (lodash_1.default.isString(countryUrls)) {
+                    countryUrls = { any: [countryUrls] };
+                }
+                else {
+                    const targets = Object.entries(countryUrls);
+                    for (let [country, urls] of targets) {
+                        if (!Array.isArray(urls)) {
+                            countryUrls[country] = [urls];
+                        }
+                    }
+                }
+                const urlReducer = (total, arr) => total + arr.length;
+                const urlCount = Object.values(countryUrls).reduce(urlReducer, 0);
+                const countryCodes = Object.keys(countryUrls).join(", ");
+                anyhow_1.default.info("LinkManager.loadFile", id, `${urlCount} links for countries ${countryCodes}`);
+                const linkData = {
+                    id: id,
+                    source: source,
+                    urls: countryUrls
+                };
+                if (id == "default" || id == source) {
+                    this.links[source] = linkData;
+                }
+                else {
+                    this.links[`${source}-${id}`] = linkData;
+                }
+            }
+        }
+        catch (ex) {
+            anyhow_1.default.error("LinkManager.loadFile", filepath, ex);
+            throw ex;
+        }
+    };
+    urlFor = (id, country, sources, search) => {
+        const sourcesLog = sources?.length > 0 ? sources.join(", ") : "any source";
+        if (!sources || sources.length == 0) {
+            sources = this.sources;
+        }
+        try {
+            if (!id) {
+                throw new Error("Missing link ID");
+            }
+            const foundLinks = [];
+            id = id.toLowerCase();
+            const alias = this.aliases[id];
+            const directLink = this.links[id] || this.links[alias];
+            if (directLink) {
+                foundLinks.push(directLink);
+            }
+            else if (sources?.length > 0) {
+                for (let source of sources) {
+                    let sourceLink = this.links[`${source}-${id}`] || this.links[`${source}-${alias}`];
+                    if (!sourceLink && settings.links.autoPlural) {
+                        sourceLink = this.links[`${source}-${id}s`] || this.links[`${source}-${alias}s`];
+                    }
+                    if (sourceLink) {
+                        foundLinks.push(sourceLink);
+                    }
+                }
+            }
+            if (foundLinks.length == 0 && search) {
+                for (let source of sources) {
+                    const sourceLink = this.links[`${source}-search`];
+                    if (sourceLink) {
+                        foundLinks.push(sourceLink);
+                    }
+                }
+            }
+            if (foundLinks.length == 0) {
+                anyhow_1.default.warn("LinkManager.urlFor", id, "Link not found");
+                return null;
+            }
+            const countryAlias = countrymanager_1.default.aliases[country];
+            const countryLinks = foundLinks.filter((link) => link.urls[country] || link.urls[countryAlias] || link.urls.any);
+            if (countryLinks.length == 0) {
+                anyhow_1.default.warn("LinkManager.urlFor", id, `${search ? "Search" : "Link"} not found for country ${country}`);
+                return null;
+            }
+            const singleLink = lodash_1.default.sample(countryLinks);
+            const result = {
+                url: lodash_1.default.sample(singleLink.urls[country] || singleLink.urls[countryAlias] || singleLink.urls.any),
+                source: singleLink.source
+            };
+            if (search) {
+                result.url = result.url.replace("{{query}}", (0, utils_1.getSearchQuery)(id, result.source));
+            }
+            anyhow_1.default.info("LinkManager.urlFor", id, country, sourcesLog, result.url);
+            return result;
+        }
+        catch (ex) {
+            anyhow_1.default.error("LinkManager.urlFor", id, country, sourcesLog, ex);
+            return null;
+        }
+    };
+}
+exports.LinkManager = LinkManager;
+exports.default = LinkManager.Instance;

package/lib/server.d.ts

@@ -0,0 +1,17 @@
+import express = require("express");
+export declare class Server {
+    private constructor();
+    private static _instance;
+    static get Instance(): Server;
+    app: express.Express;
+    init: (app?: express.Express, basePath?: string) => Promise<void>;
+    indexRoute: (req: express.Request, res: express.Response) => Promise<void>;
+    notFoundRoute: (req: express.Request, res: express.Response) => Promise<void>;
+    linkRoute: (req: express.Request, res: express.Response) => Promise<void>;
+    apiListRoute: (req: express.Request, res: express.Response) => Promise<void>;
+    apiCheckCredentials: (req: express.Request, res: express.Response) => boolean;
+    getClientIP: (req: express.Request) => string;
+    getClientCountry: (req: express.Request, ip?: string) => Promise<string>;
+}
+declare const _default: Server;
+export default _default;

package/lib/server.js

@@ -0,0 +1,164 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Server = void 0;
+const countrymanager_1 = __importDefault(require("./countrymanager"));
+const linkmanager_1 = __importDefault(require("./linkmanager"));
+const fs_1 = __importDefault(require("fs"));
+const anyhow_1 = __importDefault(require("anyhow"));
+const jaul_1 = __importDefault(require("jaul"));
+const path_1 = __importDefault(require("path"));
+const express = require("express");
+let settings;
+class Server {
+    constructor() { }
+    static _instance;
+    static get Instance() {
+        return this._instance || (this._instance = new this());
+    }
+    app;
+    init = async (app, basePath) => {
+        settings = require("setmeup").settings.countryLinkify;
+        if (!settings.server.apiKey) {
+            throw new Error(`Missing "server.apiKey" on settings`);
+        }
+        if (!settings.server.apiToken) {
+            throw new Error(`Missing "server.apiToken" on settings`);
+        }
+        if (!app) {
+            if (!settings.server.url) {
+                throw new Error(`Missing "server.url" on settings`);
+            }
+            if (!settings.server.port) {
+                throw new Error(`The "server.port" must be a valid port number`);
+            }
+            this.app = express();
+        }
+        else {
+            this.app = app;
+        }
+        if (!basePath) {
+            basePath = "/";
+        }
+        this.app.use(basePath, express.static(path_1.default.join(__dirname, "../assets")));
+        this.app.get(basePath, this.indexRoute);
+        this.app.get(`${basePath}404`, this.notFoundRoute);
+        this.app.get(`${basePath}${settings.server.apiKey}/list`, this.apiListRoute);
+        this.app.get(`${basePath}l/:id`, this.linkRoute);
+        this.app.get(`${basePath}s/:search`, this.linkRoute);
+        if (!app) {
+            this.app.listen(settings.server.port, () => anyhow_1.default.info("Server", `Listeing on port ${settings.server.port}`));
+        }
+    };
+    indexRoute = async (req, res) => {
+        anyhow_1.default.debug("Server.indexRoute", req.originalUrl);
+        res.redirect(settings.app.homeUrl || "/404");
+    };
+    notFoundRoute = async (req, res) => {
+        anyhow_1.default.debug("Server.notFoundRoute", req.originalUrl);
+        const template = fs_1.default.readFileSync(path_1.default.join(__dirname, "../assets/404.html"), "utf8");
+        const linkIds = Object.keys(linkmanager_1.default.links);
+        const logoIds = [];
+        for (let id of linkIds) {
+            const imagePath = path_1.default.join(__dirname, `../assets/images/${id}.png`);
+            if (fs_1.default.existsSync(imagePath)) {
+                logoIds.push(id);
+            }
+        }
+        const aTags = logoIds.map((id) => `<a href="https://links.devv.com/l/${id}"><img src="/images/${id}.png" /></a>`);
+        res.send(jaul_1.default.data.replaceTags(template, { logos: aTags.join(" ") }));
+    };
+    linkRoute = async (req, res) => {
+        let ip = this.getClientIP(req);
+        let country = await this.getClientCountry(req, ip);
+        let countryLog = country;
+        if (!country) {
+            country = settings.country.default;
+            countryLog = `default ${settings.country.default}`;
+        }
+        const search = req.params.search;
+        const linkId = decodeURIComponent(req.params.id || search);
+        const sources = req.query.sources ? req.query.sources.toString().split(",") : null;
+        const target = linkmanager_1.default.urlFor(linkId, country, sources, search ? true : false);
+        if (!target) {
+            anyhow_1.default.debug("Server.linkRoute", req.params.id, "404");
+            res.redirect("/404");
+            return;
+        }
+        anyhow_1.default.debug("Server.linkRoute", req.params.id, target);
+        if (req.query.rn != "1") {
+            anyhow_1.default.info("Server.linkRoute", req.params.id, `IP: ${ip}`, `Country: ${countryLog}`, target.source, target.url);
+            res.redirect(target ? target.url : "/404");
+            return;
+        }
+        const template = fs_1.default.readFileSync(path_1.default.join(__dirname, "../assets/redir.html"), "utf8");
+        const tags = {
+            from: req.query.from || "Devv",
+            target: target.source,
+            url: target.url,
+            logo: fs_1.default.existsSync(path_1.default.join(__dirname, `../assets/images/${target.source}.png`)) ? target.source : "nologo"
+        };
+        anyhow_1.default.info("Server.linkRoute", req.params.id, `IP: ${ip}`, `Country: ${countryLog}`, "Redirection notice", target.source, target.url);
+        res.send(jaul_1.default.data.replaceTags(template, tags));
+    };
+    apiListRoute = async (req, res) => {
+        if (!this.apiCheckCredentials(req, res))
+            return;
+        res.json(linkmanager_1.default.links);
+    };
+    apiCheckCredentials = (req, res) => {
+        const denied = { message: "Access denied" };
+        try {
+            const header = req.headers["authorization"];
+            const token = header && header.indexOf(" ") > 0 ? header.split(" ")[1] : null;
+            if (token != settings.server.apiToken) {
+                anyhow_1.default.warn("Server.apiCheckCredentials", req.originalUrl, "Access denied");
+                res.status(401).json(denied);
+                return false;
+            }
+        }
+        catch (ex) {
+            anyhow_1.default.error("Server.apiCheckCredentials", req.originalUrl, ex);
+            res.status(401).json(denied);
+            return false;
+        }
+        return true;
+    };
+    getClientIP = (req) => {
+        const xfor = req.headers["x-forwarded-for"];
+        if (xfor != null && xfor != "") {
+            const ip = xfor.toString().split(",")[0];
+            anyhow_1.default.debug("Server.getClientIP", req.originalUrl, `From header: ${ip}`);
+            return ip;
+        }
+        if (req.socket && req.socket.remoteAddress) {
+            const ip = req.socket.remoteAddress;
+            anyhow_1.default.debug("Server.getClientIP", req.originalUrl, `From socket: ${ip}`);
+            return ip;
+        }
+        anyhow_1.default.debug("Server.getClientIP", req.originalUrl, `From req.ip: ${req.ip}`);
+        return req.ip;
+    };
+    getClientCountry = async (req, ip) => {
+        if (!ip)
+            ip = this.getClientIP(req);
+        if (!ip || ip.includes("127.0.0.1")) {
+            return settings.country.default;
+        }
+        const cfHeader = req.headers["cf-ipcountry"];
+        if (cfHeader) {
+            anyhow_1.default.debug("Server.getClientCountry", `IP ${ip}`, `From CF header: ${cfHeader}`);
+            return cfHeader.toString().toLowerCase();
+        }
+        const ipCountry = await countrymanager_1.default.getForIP(ip);
+        if (ipCountry) {
+            anyhow_1.default.debug("Server.getClientCountry", `IP ${ip}`, `From IP: ${ipCountry}`);
+            return ipCountry;
+        }
+        return null;
+    };
+}
+exports.Server = Server;
+exports.default = Server.Instance;

package/lib/start.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/start.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+if (!process.env.NODE_ENV) {
+    process.env.NODE_ENV = "development";
+}
+const anyhow_1 = __importDefault(require("anyhow"));
+anyhow_1.default.setup("console");
+anyhow_1.default.setOptions({
+    appName: "Country Linkify",
+    timestamp: false,
+    levelOnConsole: true,
+    preprocessors: ["friendlyErrors", "maskSecrets"]
+});
+if (process.env.NODE_ENV == "production" && process.env.JSON_LOGGING) {
+    const consoleLog = (level, message) => {
+        level = level.toUpperCase();
+        if (level == "WARN")
+            level = "WARNING";
+        console.log(JSON.stringify({ severity: level, message: message }));
+    };
+    const gcloudLogging = {
+        name: "gcloud",
+        log: consoleLog
+    };
+    anyhow_1.default.setOptions({ levelOnConsole: false });
+    anyhow_1.default.info("CountryLinkify.startup", "Switching to JSON logging now");
+    anyhow_1.default.setup(gcloudLogging);
+}
+let terminating = false;
+const shutdown = async (code) => {
+    if (terminating)
+        return;
+    terminating = true;
+    if (!code)
+        code = 0;
+    anyhow_1.default.warn("CountryLinkify.shutdown", `Code ${code}`, "Terminating the service now...");
+    process.exit();
+};
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+const index_1 = __importDefault(require("./index"));
+(0, index_1.default)();

package/lib/types.d.ts

@@ -0,0 +1,11 @@
+export interface Link {
+    id: "default" | "search" | string;
+    source: string;
+    urls: {
+        [country: string]: string[];
+    };
+}
+export interface TargetURL {
+    url: string;
+    source: string;
+}

package/lib/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils.d.ts

@@ -0,0 +1 @@
+export declare const getSearchQuery: (id: string, source: string) => string;

package/lib/utils.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSearchQuery = void 0;
+const getSearchQuery = (id, source) => {
+    if (source == "aliexpress") {
+        return id.replace(/[^a-zA-Z ]/g, "").replace(/ /g, "-");
+    }
+    if (source == "decathlon" || source == "ribble") {
+        return encodeURIComponent(encodeURIComponent(id));
+    }
+    return encodeURIComponent(id);
+};
+exports.getSearchQuery = getSearchQuery;

package/package.json

@@ -0,0 +1,54 @@
+{
+    "name": "country-linkify",
+    "version": "24.482.11825",
+    "description": "Simple service to redirect links based on the client's country.",
+    "keywords": [
+        "bit.ly",
+        "country",
+        "linkify",
+        "redirect"
+    ],
+    "author": "Igor Ramadas <igor@devv.com>",
+    "homepage": "https://country-linkify.devv.com",
+    "subdomain": "country-linkify",
+    "license": "MIT",
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/igoramadas/country-linkify.git"
+    },
+    "engines": {
+        "node": ">= 16.0"
+    },
+    "scripts": {
+        "prepublishOnly": "./node_modules/.bin/tsc --removeComments",
+        "docs": "make docs",
+        "start": "node lib/start.js"
+    },
+    "dependencies": {
+        "anyhow": "^3.4.0",
+        "bent": "^7.3.12",
+        "bitecache": "^1.3.3",
+        "chalk": "^4.1.2",
+        "express": "^5.0.1",
+        "jaul": "^1.7.1",
+        "lodash": "^4.17.21",
+        "setmeup": "^1.9.3"
+    },
+    "devDependencies": {
+        "@types/express": "^5.0.0",
+        "@types/lodash": "^4.17.13",
+        "@types/node": "^22.10.0",
+        "typescript": "^5.7.2"
+    },
+    "prettier": {
+        "trailingComma": "none",
+        "tabWidth": 4,
+        "semi": false,
+        "singleQuote": false,
+        "arrowParens": "always",
+        "bracketSpacing": false,
+        "printWidth": 250
+    }
+}

package/settings.development.json

@@ -0,0 +1,18 @@
+// COUNTRY LINKIFY SETTINGS (DEVELOPMENT)
+
+{
+    "countryLinkify": {
+        // Debugging is active on dev.
+        "debug": true,
+        // Server options on dev.
+        "server": {
+            "url": "http://linkify.local:3579/",
+            // API identifier, by default it's "api" meaning Admin API endpoints will be available at /api/.
+            "apiKey": "api",
+            // Bearer token to be passed for authentication.
+            "apiToken": "123",
+            // Server port on dev.
+            "port": 3579
+        }
+    }
+}

package/settings.json

@@ -0,0 +1,52 @@
+// COUNTRY LINKIFY DEFAULT SETTINGS
+
+{
+    "countryLinkify": {
+        "app": {
+            // Homepage should redirect to this URL. If set to "null",
+            // it will display all links with logos instead.
+            "homeUrl": null,
+            // Application title.
+            "title": "Country Linkify"
+        },
+        "country": {
+            // Cache country for IP results for up to 30 minutes.
+            "cacheDuration": 900,
+            // Default country.
+            "default": "us"
+            // If country can't be determined or there's no link for the user's country, you can add
+            // aliases / target countries here. For example, the following will set Spain as default
+            // for Portuguese users, Germany for Austrian and Swiss users, and United Kingdom for Great Britain.
+            // "es": ["pt"]
+            // "de": ["at", "ch"]
+            // "uk": ["gb"]
+        },
+        "links": {
+            // Default folder is /links on the application root. This can also be set to an absolute path.
+            "path": "./links",
+            // Auto reload links when the JSON files change. Set to false to disable.
+            "autoReload": true,
+            // Also check for plural names when matching link IDs.
+            "autoPlural": true,
+            // Link aliases.
+            // Sample: "light": ["led", "bulb"]
+            "aliases": {}
+        },
+        "server": {
+            // Base server URL, can be left as null if using as part of another website / app.
+            // Must be set when running in standalone mode.
+            "url": null,
+            // Server port, required if the url above is also set.
+            "port": null,
+            // Admin API key used as part of the API endpoint. For example if you set this to "my-api"
+            // then the Admin API will be available at /my-api/.
+            "apiKey": null,
+            // Bearer token to be passed on Admin API requests.
+            "apiToken": null
+        },
+        // Name of the bitecache collection.
+        "cacheName": "ip-country",
+        // Default encoding is set to UTF-8.
+        "encoding": "utf8"
+    }
+}

package/settings.production.sample.json

@@ -0,0 +1,36 @@
+// COUNTRY LINKIFY SETTINGS (PRODUCTION SAMPLE)
+
+{
+    "countryLinkify": {
+        "app": {
+            // Homepage should redirect to devv.com.
+            "homeUrl": "https://devv.com/",
+            // Application title.
+            "title": "My Links"
+        },
+        "country": {
+            // Set default country to Brazil, and add some aliases.
+            "default": "br",
+            "es": ["mt", "pt"],
+            "de": ["at", "be", "ch", "cz", "dk", "ee", "gi", "fi", "fr", "hu", "ie", "it", "nl", "no", "pl", "se", "sk"],
+            "uk": ["gb"],
+            "us": ["ca"]
+        },
+        "links": {
+            // Cycling aliases.
+            "aliases": {
+                "bike": ["bicycle"],
+                "tire": ["tyre"]
+            }
+        },
+        // Server options on prod.
+        "server": {
+            "url": "https://links.devv.com/",
+            "port": 8080,
+            // Admin API base endpoint should be https://links.devv.com/secret-api/.
+            "apiKey": "secret-api",
+            // Admin API bearer token.
+            "apiToken": "some-token"
+        }
+    }
+}