@levo-so/next-middleware 0.1.97 → 0.3.7

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

@@ -16,6 +16,8 @@ declare function middleware(request: NextRequest, options?: {
 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

@@ -22,12 +22,35 @@ function middleware(request, options = {}) {
         // new URL(request.url).protocol = "http:"
         modified_headers.set("origin", `${new URL(request.url).protocol}//${host}`);
     }
+    // Dev-only: tell the backend the proxied request is https so its
+    // ingress-nginx `force-ssl-redirect` doesn't 308 us to a port-stripped
+    // URL (`next dev` serves over plain http). Gated off in production, where
+    // genuine http must still redirect and these paths bypass this code.
+    if (process.env.NODE_ENV !== "production") {
+        modified_headers.set("x-forwarded-proto", "https");
+    }
     if (host && pathname.startsWith("/.levo/public/api")) {
         const targetPath = pathname.replace(/^\/.levo\/public\/api/, "");
         const workspaceQuery = workspace && !search.includes("workspace=")
             ? `${search ? "&" : "?"}workspace=${workspace}`
             : "";
         const targetURL = `${apiUrl}${targetPath}${search}${workspaceQuery}${hash}`;
+        // SSE endpoints must opt out of Next.js's gzip layer when running under
+        // `next dev`. Dev mode buffers ~16KB before flushing, which collapses
+        // per-token text-deltas into one frame and breaks the wire-level streaming
+        // the BE provides. We can't set a response header from middleware on
+        // absolute-URL rewrites (Next discards them), so we override the incoming
+        // `Accept-Encoding` to `identity` — Next's compression middleware reads
+        // request accept-encoding before deciding to gzip, and `identity` skips it.
+        //
+        // Gated to `NODE_ENV !== "production"` because production runs behind a
+        // CDN / nginx layer that handles SSE pass-through correctly; we don't want
+        // to force-disable encoding negotiation for real traffic. `NODE_ENV` is
+        // inlined at build time, so the entire block is dead-code-eliminated from
+        // the production bundle.
+        if (process.env.NODE_ENV !== "production" && targetPath.endsWith("/stream")) {
+            modified_headers.set("accept-encoding", "identity");
+        }
         return NextResponse.rewrite(targetURL, {
             request: {
                 headers: modified_headers,
@@ -82,5 +105,7 @@ const levoConfig = {
         "/(.*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,37 +1,38 @@
 {
   "name": "@levo-so/next-middleware",
-  "version": "0.1.97",
-  "author": "Levo Engineering <devs@theinternetfolks.com>",
   "description": "Next middleware to add a proxy for levo integration in apps",
-  "type": "module",
-  "sideEffects": false,
-  "publishConfig": {
-    "access": "public"
-  },
-  "files": [
-    "dist/**",
-    "!dist/**/*.d.ts.map",
-    "package.json"
-  ],
-  "peerDependencies": {
-    "next": ">13.0.0 <=17"
-  },
+  "version": "0.3.7",
+  "author": "Levo Engineering <devs@theinternetfolks.com>",
   "devDependencies": {
     "@types/react": "19.2.14",
     "@types/react-dom": "19.2.3",
     "babel-plugin-react-compiler": "19.1.0-rc.3",
-    "next": "16.2.1",
+    "next": "16.2.6",
     "react": "19.2.4",
     "react-dom": "19.2.4",
     "@levo/ts-config": "0.0.0"
   },
+  "files": [
+    "dist/**",
+    "!dist/**/*.d.ts.map",
+    "!dist/**/*.js.map",
+    "package.json"
+  ],
   "main": "./dist/index.js",
   "module": "./dist/index.js",
+  "peerDependencies": {
+    "next": ">13.0.0 <=17"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "type": "module",
   "types": "./dist/index.d.ts",
   "scripts": {
-    "clean": "rimraf dist node_modules .turbo",
-    "check-types": "tsc --noEmit",
     "build": "tsc",
+    "check-types": "tsc --noEmit",
+    "clean": "npx rimraf dist node_modules .turbo",
     "dev": "tsc --watch"
   }
 }