Multi-country website from one codebase

.
├── src/                          # core: knows a country only through the contract
│   ├── app/                      # routes with neutral English names
│   ├── lib/country-config.ts     # contract: identity, language, domain, public paths
│   ├── lib/country-content.ts    # contract: curated maps, place themes, calendar
│   ├── lib/country-services.ts   # contract: optional services
│   └── country -> ../countries/cz   # symlink to the selected country
├── countries/
│   ├── index.ts                  # registry of all countries (links between them)
│   ├── cz/
│   │   ├── config.ts             # CountryConfig
│   │   ├── services.ts           # CountryServices
│   │   ├── messages.ts           # UI translations (empty for Czech)
│   │   ├── providers/            # the country's data sources
│   │   ├── content/              # curated maps, gazetteer, country outline
│   │   ├── docs/                 # public documentation in the country's language
│   │   └── scripts/              # generators of the country's data
│   └── sk/                       # the same shape + its own wrangler.jsonc
├── worker.ts                     # one entry point for every country
├── wrangler.jsonc                # worker of the default country (cz)
└── scripts/                      # use-country, check-countries, cf (deploy)

// src/lib/country-config.ts (shortened): everything the core may know about a country
export type PageKey = "places" | "maps" | "topics" | "sources" | "docs" | "register" | "unreviewed" | "datasets";
export type FileKey = "places.geojson" | "municipalities.json" | "sources.md" | "examples";
export type DocKey = "providers" | "ai-agents" | "ai-assistants" | "protocol" | "api" | "about";

export type CountryConfig = {
  id: string;                                // "cz", the same as the folder name
  locale: string;                            // "cs-CZ": language of texts for people
  origin: string;                            // canonical domain: "https://datovamapa.cz"
  bounds: [number, number, number, number];  // where the map opens
  timeZone: string;                          // what "today" means
  regions: { name: string; slug: string }[]; // top-level administrative units
  basemap?: { tileJsonUrl?: string; tileUrl?: string; attribution?: string };
  paths: {
    pages: Record<PageKey, string>;          // public URL segments in the country's language
    files: Record<FileKey, string>;
    docs: Record<DocKey, string>;
    categories: Record<string, string>;
  };
};

// countries/sk/config.ts (shortened)
import type { CountryConfig } from "../../src/lib/country-config";

export const country: CountryConfig = {
  id: "sk",
  locale: "sk-SK",
  origin: "https://datovamapa.sk",
  bounds: [16.83, 47.73, 22.57, 49.62],
  timeZone: "Europe/Bratislava",
  regions: [
    { name: "Bratislavský kraj", slug: "bratislavsky-kraj" },
    // ... 7 more
  ],
  // until Slovakia has its own tile server: OpenFreeMap (OpenMapTiles schema)
  basemap: { tileJsonUrl: "https://tiles.openfreemap.org/planet" /* , attribution: ... */ },
  paths: {
    pages: {
      places: "miesta", maps: "mapy", topics: "temy", sources: "zdroje",
      docs: "dokumentacia", register: "registracia", unreviewed: "neschvalene-data", datasets: "mapa",
    },
    // files, docs and categories the same way
  },
};

// the core reaches the selected country through one path only
import { country } from "@/country/config";
import { services } from "@/country/services";
import { registry } from "@/country/providers/registry";

// scripts/use-country.ts (shortened): src/country -> countries/<COUNTRY>
import { existsSync, lstatSync, readlinkSync, symlinkSync, unlinkSync } from "node:fs";
import { join } from "node:path";

const root = join(import.meta.dirname, "..");
const id = process.env.COUNTRY ?? "cz";
if (!/^[a-z]{2,8}$/.test(id) || !existsSync(join(root, "countries", id, "config.ts"))) {
  console.error(`Country "${id}" does not exist: countries/${id}/config.ts is missing.`);
  process.exit(1);
}

const link = join(root, "src", "country");
const target = join("..", "countries", id);
const stat = lstatSync(link, { throwIfNoEntry: false });
if (stat && !stat.isSymbolicLink()) {
  console.error("src/country must be a symlink, not a folder.");
  process.exit(1);
}
if (!stat || readlinkSync(link, { encoding: "utf8" }) !== target) {
  if (stat) unlinkSync(link);
  symlinkSync(target, link, "dir");
}

// package.json: dev and build switch the country by themselves
"predev":   "tsx scripts/use-country.ts && tsx scripts/i18n.ts --write",
"prebuild": "tsx scripts/use-country.ts && tsx scripts/i18n.ts --write",
"country":  "tsx scripts/use-country.ts"

// countries/index.ts: every country, independent of the symlink
import type { CountryConfig } from "../src/lib/country-config";
import { country as cz } from "./cz/config";
import czOutline from "./cz/content/outline.json";
import { country as sk } from "./sk/config";
import skOutline from "./sk/content/outline.json";

export type CountryEntry = { config: CountryConfig; outline: [number, number][][][] };

export const countries: CountryEntry[] = [
  { config: cz, outline: czOutline.shape as [number, number][][][] },
  { config: sk, outline: skOutline.shape as [number, number][][][] },
];

// src/lib/paths.ts (shortened): neutral routes inside, the country's language outside
import { country } from "../country/config";
const { pages: PAGE_PATHS } = country.paths;

// routeHref("docs", "api") -> "/dokumentace/api" in cz, "/dokumentacia/api" in sk
export const routeHref = (key: PageKey, ...rest: string[]) => `/${[PAGE_PATHS[key], ...rest].join("/")}`;

// for next.config.ts: public segment -> internal route
export function pathRewrites() {
  return Object.entries(PAGE_PATHS).flatMap(([internal, publicName]) => [
    { source: `/${publicName}`, destination: `/${internal}` },
    { source: `/${publicName}/:path*`, destination: `/${internal}/:path*` },
  ]);
}

// in the core: the Czech source text is the key
const text = t("Chyba: {message}", { message });

// countries/sk/messages.ts: Czech source -> Slovak translation (the Czech catalog is empty)
export const messages: Record<string, string> = {
  "DatováMapa": "DátováMapa",
  "## Dokumentace": "## Dokumentácia",
  "[lon, lat] ve WGS84, např. [14.4378, 50.0755]": "[lon, lat] vo WGS84, napr. [17.1077, 48.1486]",
};

// next.config.ts: the browser gets only the translations of client code, the server the whole catalog
turbopack: {
  resolveAlias: {
    "@/country/messages": { browser: "./src/country/messages.client.ts" },
  },
},
async rewrites() {
  return pathRewrites();
},

COUNTRY=sk npm run i18n                # sources, missing translations, unused keys
COUNTRY=sk npm run i18n -- --missing   # missing sources as JSON, input for translation
COUNTRY=sk npm run i18n -- --check     # fails when anything is missing or left over

// src/lib/country-services.ts (shortened): every service is optional
export type CountryServices = {
  /** Address, street or municipality search. */
  geocoder?: { attribution: string; search(text: string): Promise<GeocoderHit[]> };
  /** Municipality boundary by code. */
  boundaries?: { download(code: string): Promise<Ring[][] | undefined> };
  /** Figures for a region. */
  regionStatistics?: { providerId: string; load(regionName: string): Promise<RegionFigures[]> };
};

// countries/sk/services.ts: no address search yet, so the core switches it off
export const services: CountryServices = {
  boundaries: { download: async (code) => shapes.get(code) },
  regionStatistics: { providerId: REGION_STATISTICS_PROVIDER, load: regionStatistics },
};

// src/app/[region]/page.tsx: no statistics service, no figures on the region page
const statistics = (await services.regionStatistics?.load(region.name)) ?? [];

// src/lib/server/geocode.ts: no geocoder, a clear error instead of a crash
const geocoder = services.geocoder;
if (!geocoder) throw new RequestError(t("Hledání adres a míst v této zemi zatím není dostupné."), 501, "geocoding_unavailable");

// scripts/check-countries.ts (shortened): every country, one after another
const countries = readdirSync("countries").filter((id) => existsSync(`countries/${id}/config.ts`));
const previous = basename(readlinkSync("src/country", { encoding: "utf8" }));
const run = (id: string, args: string[]) =>
  spawnSync("npx", args, { stdio: "inherit", env: { ...process.env, COUNTRY: id } }).status === 0;

const failed: string[] = [];
try {
  for (const id of countries) {
    run(id, ["tsx", "scripts/use-country.ts"]);
    if (!run(id, ["tsc", "--noEmit"])) failed.push(`${id}: types`);
    if (!run(id, ["tsx", "scripts/check-docs.ts"])) failed.push(`${id}: docs`);
    if (!run(id, ["tsx", "scripts/i18n.ts", "--check"])) failed.push(`${id}: translations`);
  }
} finally {
  run(previous, ["tsx", "scripts/use-country.ts"]); // back to the country selected before
}
if (failed.length) process.exit(1);

// countries/sk/wrangler.jsonc: every path is relative to THIS file
{
  "$schema": "../../node_modules/wrangler/config-schema.json",
  "name": "datovamapa-sk",
  "main": "../../worker.ts",
  "workers_dev": false,
  "preview_urls": false,
  "compatibility_date": "2026-08-12",
  "compatibility_flags": ["global_fetch_strictly_public"],
  "assets": { "binding": "ASSETS", "directory": "../../.open-next/assets" },
  "images": { "binding": "IMAGES" },
  // must match "name": a copied "datovamapa" would call the Czech worker
  "services": [{ "binding": "WORKER_SELF_REFERENCE", "service": "datovamapa-sk" }],
  "d1_databases": [
    { "binding": "DB", "database_name": "datovamapa_sk", "database_id": "<D1_ID_SK>", "migrations_dir": "../../migrations" }
  ],
  // namespace_id must be unique in the account (cz uses 1001)
  "ratelimits": [{ "name": "REGISTRATION_LIMIT", "namespace_id": "2001", "simple": { "limit": 5, "period": 60 } }],
  "send_email": [{ "name": "EMAIL" }],
  "version_metadata": { "binding": "CF_VERSION_METADATA" },
  "vars": { "NOTIFY_FROM": "registracia@mail.datovamapa.sk" },
  "observability": { "enabled": true },
  "upload_source_maps": true,
  "limits": { "cpu_ms": 750 }
}

// scripts/lib/wrangler.ts: the country's worker and D1 for every wrangler call
import { existsSync } from "node:fs";
import { join } from "node:path";

export const root = join(import.meta.dirname, "..", "..");
export const countryId = process.env.COUNTRY ?? "cz";

const config = join("countries", countryId, "wrangler.jsonc");
/** "--config ..." for a country with its own config, otherwise nothing (cz uses the root file). */
export const wranglerConfigArgs = existsSync(join(root, config)) ? ["--config", config] : [];

npm run deploy                # Czechia: root wrangler.jsonc
COUNTRY=sk npm run deploy     # Slovakia: countries/sk/wrangler.jsonc