@levo-so/next-middleware 0.1.82 → 0.1.102

package/dist/geoIp.d.ts

@@ -0,0 +1,37 @@
+/**
+ * GeoIP header extractor.
+ *
+ * Pulls visitor country + language from HTTP headers across CDN providers
+ * (Cloudflare, Vercel, AWS CloudFront, Azure, BunnyCDN), nginx-ingress, and
+ * Traefik GeoIP2. Only surfaces `bestCountry` + `languageData` — the helpers
+ * that were historically exported (client IPs, provider-specific getters,
+ * raw header maps) are no longer used by any consumer.
+ */
+export interface ICountryInfo {
+    countryCode: string;
+    city?: string;
+    region?: string;
+    latitude?: string;
+    longitude?: string;
+    source: string;
+}
+export interface ILanguageInfo {
+    locale: string;
+    language: string;
+    region?: string;
+    quality: number;
+}
+export interface IParsedLanguageData {
+    languages: ILanguageInfo[];
+    primaryLanguage: string;
+    inferredRegions: string[];
+}
+/**
+ * Main entry: extract visitor country + language preferences.
+ * Accepts any header carrier — normalization is internal.
+ */
+export declare const extractGeoAndLanguageData: (headers: Record<string, string | string[]> | Headers | null | undefined) => {
+    bestCountry: ICountryInfo | null;
+    languageData: IParsedLanguageData;
+};
+//# sourceMappingURL=geoIp.d.ts.map

package/dist/geoIp.js

@@ -0,0 +1,129 @@
+/**
+ * GeoIP header extractor.
+ *
+ * Pulls visitor country + language from HTTP headers across CDN providers
+ * (Cloudflare, Vercel, AWS CloudFront, Azure, BunnyCDN), nginx-ingress, and
+ * Traefik GeoIP2. Only surfaces `bestCountry` + `languageData` — the helpers
+ * that were historically exported (client IPs, provider-specific getters,
+ * raw header maps) are no longer used by any consumer.
+ */
+const safeDecode = (value) => {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+};
+/** Best country info from CDN (preferred) or nginx/traefik (fallback). */
+const extractCountry = (headers) => {
+    // Cloudflare — "XX" is Cloudflare's "unknown" sentinel
+    const cf = headers["cf-ipcountry"];
+    if (cf && cf !== "XX")
+        return { countryCode: cf, source: "Cloudflare CDN" };
+    // Vercel Edge — city is URL-encoded (e.g. `San%20Francisco`)
+    const vercel = headers["x-vercel-ip-country"];
+    if (vercel) {
+        const rawCity = headers["x-vercel-ip-city"];
+        return {
+            countryCode: vercel,
+            city: rawCity ? safeDecode(rawCity) : undefined,
+            region: headers["x-vercel-ip-country-region"],
+            latitude: headers["x-vercel-ip-latitude"],
+            longitude: headers["x-vercel-ip-longitude"],
+            source: "Vercel Edge",
+        };
+    }
+    const aws = headers["cloudfront-viewer-country"];
+    if (aws)
+        return { countryCode: aws, source: "AWS CloudFront" };
+    const azure = headers["x-azure-country"];
+    if (azure)
+        return { countryCode: azure, source: "Azure CDN" };
+    const bunny = headers["x-edge-country"];
+    if (bunny)
+        return { countryCode: bunny, source: "BunnyCDN" };
+    const generic = headers["x-client-country"] || headers["x-forwarded-country"] || headers["x-country"];
+    if (generic)
+        return { countryCode: generic, source: "Generic CDN" };
+    // Infrastructure fallbacks
+    const nginx = headers["x-country-code"];
+    if (nginx) {
+        return {
+            countryCode: nginx,
+            city: headers["x-city"],
+            latitude: headers["x-latitude"],
+            longitude: headers["x-longitude"],
+            source: "nginx-ingress",
+        };
+    }
+    const traefik = headers["x-geoip2-country"];
+    if (traefik) {
+        return {
+            countryCode: traefik,
+            city: headers["x-geoip2-city"],
+            region: headers["x-geoip2-region"],
+            source: "traefik-geoip2",
+        };
+    }
+    return null;
+};
+/** Parse Accept-Language into quality-sorted list + derived regions. */
+const parseAcceptLanguage = (acceptLanguage) => {
+    if (!acceptLanguage) {
+        return { languages: [], primaryLanguage: "unknown", inferredRegions: [] };
+    }
+    const languages = acceptLanguage
+        .split(",")
+        .map((lang) => {
+        const [locale, quality] = lang.trim().split(";q=");
+        const [language, region] = (locale || "").split("-");
+        return {
+            locale: locale?.trim() || "",
+            language: language?.trim() || "",
+            region: region?.trim().toUpperCase(),
+            quality: quality ? parseFloat(quality) : 1.0,
+        };
+    })
+        .filter((l) => l.locale)
+        .sort((a, b) => b.quality - a.quality);
+    const inferredRegions = languages
+        .map((l) => l.region)
+        .filter((r) => Boolean(r))
+        .filter((r, i, arr) => arr.indexOf(r) === i);
+    return {
+        languages,
+        primaryLanguage: languages[0]?.locale || "unknown",
+        inferredRegions,
+    };
+};
+/**
+ * Normalize any header carrier (Fetch `Headers`, Node `req.headers`, plain
+ * object) into a lowercase-keyed map.
+ */
+const headersToObject = (headers) => {
+    if (!headers)
+        return {};
+    if (typeof headers.entries === "function") {
+        const obj = {};
+        for (const [k, v] of headers.entries())
+            obj[k.toLowerCase()] = v;
+        return obj;
+    }
+    const obj = {};
+    for (const [k, v] of Object.entries(headers)) {
+        obj[k.toLowerCase()] = Array.isArray(v) ? v.join(", ") : String(v);
+    }
+    return obj;
+};
+/**
+ * Main entry: extract visitor country + language preferences.
+ * Accepts any header carrier — normalization is internal.
+ */
+export const extractGeoAndLanguageData = (headers) => {
+    const normalized = headersToObject(headers);
+    return {
+        bestCountry: extractCountry(normalized),
+        languageData: parseAcceptLanguage(normalized["accept-language"] || ""),
+    };
+};

package/dist/index.d.ts

@@ -1,15 +1,23 @@
 import { type NextRequest, NextResponse } from "next/server";
 /**
- * @description This function can be marked `async` if using `await` inside
+ * Levo Next.js middleware — rewrites API and SEO file requests to the appropriate backend.
+ *
+ * @param options.apiUrl - Base URL for the public API proxy. Defaults to `https://public-api.levo.so`.
+ * @param options.insightsUrl - Base URL for the insights API proxy. Defaults to `https://insights-api.levo.so`.
+ * @param options.fileExclusions - Paths to exclude from the SEO file proxy (robots.txt, llms.txt, sitemaps).
+ *   Matched exactly against the request pathname.
+ *   e.g. `["/robots.txt", "/llms.txt"]` prevents those files from being reverse-proxied.
  */
 declare function middleware(request: NextRequest, options?: {
     apiUrl?: string;
     insightsUrl?: string;
-    isHeadless?: boolean;
+    fileExclusions?: string[];
 }): NextResponse<unknown> | undefined;
 declare const levoConfig: {
     matcher: string[];
 };
+export * from "./geoIp";
+export * from "./params";
 export default middleware;
-export { middleware, levoConfig };
+export { levoConfig, middleware };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,9 +1,15 @@
 import { NextResponse } from "next/server";
 /**
- * @description This function can be marked `async` if using `await` inside
+ * Levo Next.js middleware — rewrites API and SEO file requests to the appropriate backend.
+ *
+ * @param options.apiUrl - Base URL for the public API proxy. Defaults to `https://public-api.levo.so`.
+ * @param options.insightsUrl - Base URL for the insights API proxy. Defaults to `https://insights-api.levo.so`.
+ * @param options.fileExclusions - Paths to exclude from the SEO file proxy (robots.txt, llms.txt, sitemaps).
+ *   Matched exactly against the request pathname.
+ *   e.g. `["/robots.txt", "/llms.txt"]` prevents those files from being reverse-proxied.
  */
 function middleware(request, options = {}) {
-    const { apiUrl = "https://public-api.levo.so", insightsUrl = "https://insights-api.levo.so", isHeadless = false, } = options;
+    const { apiUrl = "https://public-api.levo.so", insightsUrl = "https://insights-api.levo.so", fileExclusions = [], } = options;
     const { nextUrl } = request;
     const { pathname, search, hash } = nextUrl;
     const host = request.headers.get("host");
@@ -48,10 +54,14 @@ function middleware(request, options = {}) {
      * such as `text/plain` for `robots.txt` and `application/xml` for sitemaps
      *
      */
-    if ((!isHeadless && request.nextUrl.pathname.endsWith("robots.txt")) ||
-        (!isHeadless && request.nextUrl.pathname.endsWith("llms.txt")) ||
+    // Early return if the path is in the exclusions list
+    if (fileExclusions.includes(pathname))
+        return NextResponse.next();
+    const isFileProxy = pathname.endsWith("robots.txt") ||
+        pathname.endsWith("llms.txt") ||
         // check if it is a sitemap xml, can be `sitemap-static.xml`, `sitemap_index.xml` or other sitemap xml files
-        (request.nextUrl.pathname.includes("sitemap") && request.nextUrl.pathname.endsWith(".xml"))) {
+        (pathname.includes("sitemap") && pathname.endsWith(".xml"));
+    if (isFileProxy) {
         const workspaceQuery = workspace ? `&workspace=${workspace}` : "";
         const targetURL = `${apiUrl}/v1/studio/page/get-file-from-path?path=${pathname}${workspaceQuery}`;
         return NextResponse.rewrite(targetURL, {
@@ -63,15 +73,16 @@ function middleware(request, options = {}) {
 }
 const levoConfig = {
     matcher: [
-        /*
-         * Match all request paths except for the ones starting with:
-         * - api (API routes)
-         * - _next/static (static files)
-         * - _next/image (image optimization files)
-         * - favicon.ico (favicon file)
-         */
-        "/((?!api|_next/static|_next/image|favicon.ico).*)",
+        // API proxy routes
+        "/.levo/public/api/:path*",
+        "/.levo/insights/api/:path*",
+        // SEO file proxy routes
+        "/robots.txt",
+        "/llms.txt",
+        "/(.*sitemap.*\\.xml)",
     ],
 };
+export * from "./geoIp";
+export * from "./params";
 export default middleware;
-export { middleware, levoConfig };
+export { levoConfig, middleware };

package/dist/params.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Helpers for reading Next.js route `params` produced by the proxy's
+ * `/visitor:{...json}/...` rewrite.
+ */
+export interface IParsedRouteParams {
+    slug: string[];
+    visitorParams: Record<string, unknown>;
+}
+/** Parse a `visitor:{...}` segment back into its JSON payload. */
+export declare const parseVisitorParam: (visitor: string | undefined) => Record<string, unknown>;
+/**
+ * Pull `visitorParams` + clean `slug` out of a Next.js catch-all `params`.
+ * If the first slug segment is a `visitor:{...}` prefix, it is stripped and
+ * decoded; otherwise `visitorParams` falls back to `{}`.
+ */
+export declare const parseParams: (params: Record<string, string | string[] | undefined> | undefined) => IParsedRouteParams;
+//# sourceMappingURL=params.d.ts.map

package/dist/params.js

@@ -0,0 +1,28 @@
+/**
+ * Helpers for reading Next.js route `params` produced by the proxy's
+ * `/visitor:{...json}/...` rewrite.
+ */
+/** Parse a `visitor:{...}` segment back into its JSON payload. */
+export const parseVisitorParam = (visitor) => {
+    if (typeof visitor !== "string")
+        return {};
+    try {
+        return JSON.parse(visitor.replace(/^visitor:/, ""));
+    }
+    catch {
+        return {};
+    }
+};
+/**
+ * Pull `visitorParams` + clean `slug` out of a Next.js catch-all `params`.
+ * If the first slug segment is a `visitor:{...}` prefix, it is stripped and
+ * decoded; otherwise `visitorParams` falls back to `{}`.
+ */
+export const parseParams = (params) => {
+    const rawSlug = Array.isArray(params?.slug) ? params.slug : [];
+    const [first, ...rest] = rawSlug;
+    if (typeof first === "string" && first.startsWith("visitor:")) {
+        return { slug: rest, visitorParams: parseVisitorParam(first) };
+    }
+    return { slug: rawSlug, visitorParams: {} };
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@levo-so/next-middleware",
-  "version": "0.1.82",
+  "version": "0.1.102",
   "author": "Levo Engineering <devs@theinternetfolks.com>",
   "description": "Next middleware to add a proxy for levo integration in apps",
   "type": "module",
@@ -14,15 +14,15 @@
     "package.json"
   ],
   "peerDependencies": {
-    "next": ">13.0.0 <=16"
+    "next": ">13.0.0 <=17"
   },
   "devDependencies": {
-    "@types/react": "19.2.5",
+    "@types/react": "19.2.14",
     "@types/react-dom": "19.2.3",
     "babel-plugin-react-compiler": "19.1.0-rc.3",
-    "next": "16.0.10",
-    "react": "19.2.3",
-    "react-dom": "19.2.3",
+    "next": "16.2.3",
+    "react": "19.2.4",
+    "react-dom": "19.2.4",
     "@levo/ts-config": "0.0.0"
   },
   "main": "./dist/index.js",