@qelos/plugin-netlify-api 1.1.0 → 1.1.2

package/README.md

@@ -33,15 +33,9 @@ If your publish directory is not `dist`, set `QELOS_NETLIFY_PUBLISH` to that fol
 
 ## How it proxies (default)
 
-By default the plugin uses **Netlify’s CDN rewrite** to your Qelos API (same pattern as [Netlify’s proxy docs](https://docs.netlify.com/manage/routing/redirects/rewrites-proxies/#proxy-to-another-service)):
+**Default:** the bundled serverless function **`qelos-api-proxy`** — `/api/*` is rewritten to `/.netlify/functions/qelos-api-proxy`. That runs your Node proxy (correct `Host` / `x-forwarded-host`, optional `x-bypass-admin`, etc.).
 
-- `/api/*` → `${QELOS_API_IP origin}/api/:splat` with status `200` and `force`
-
-So `/api/me` is proxied to `http://your-api-host/api/me` **at the edge**, without a serverless function. That avoids fragile `/.netlify/functions/...` rewrites and matches Nuxt’s `_redirects` behavior.
-
-Optional: **`use_function_proxy = true`** — uses the bundled `qelos-api-proxy` serverless function instead (for cases where you must run Node logic on each request).
-
-Optional plugin inputs:
+**Optional — CDN direct to API:** set **`use_cdn_proxy = true`** to rewrite `/api/*` → `${QELOS_API_IP}/api/:splat` at the edge **without** invoking the function (faster, but no per-request logic in `qelos-api-proxy.ts`).
 
 ```toml
 [[plugins]]
@@ -50,17 +44,18 @@ Optional plugin inputs:
   [plugins.inputs]
     api_url = "http://159.203.152.168"
     bypass_admin = true
-    use_function_proxy = false
+    use_cdn_proxy = false
 ```
 
 - **api_url** — Qelos API base URL (same as `QELOS_API_IP` / `API_HOST`).
-- **bypass_admin** — If `true`, adds header `x-bypass-admin: true` on proxied requests (CDN and function modes).
-- **use_function_proxy** — If `true`, deploy the bundled `qelos-api-proxy` function and rewrite to it instead of the CDN proxy.
+- **bypass_admin** — If `true`, adds header `x-bypass-admin: true` (function mode: in the proxy; CDN mode: on the redirect when supported).
+- **use_cdn_proxy** — If `true`, edge proxy only (no `qelos-api-proxy` function). Default **false**.
+- **use_function_proxy** — Deprecated; set **`false`** to get the same as `use_cdn_proxy = true`.
 
 ## What it does
 
-- **Environment:** Sets `QELOS_API_IP`, `QELOS_NETLIFY_PROXY_MODE` (`cdn` or `function`).
-- **Redirects:** Injects the `/api/*` rewrite into `netlify.toml` (and **`postbuild`** rewrites `publish/_redirects` so Nuxt’s catch‑all does not win).
-- **Function mode only:** Copies `qelos-api-proxy.ts` into your Netlify functions directory.
+- **Environment:** Sets `QELOS_API_IP`, `QELOS_NETLIFY_PROXY_MODE` (`function` unless CDN).
+- **Redirects:** Injects `/api/*` into `netlify.toml` and **`postbuild`** updates `publish/_redirects` so Nuxt’s catch‑all does not win.
+- **Unless `use_cdn_proxy`:** copies `qelos-api-proxy.ts` into your Netlify functions directory.
 
 No need to commit redirects yourself; the plugin and `postbuild` maintain them each build.

package/functions/qelos-api-proxy.ts

@@ -29,12 +29,18 @@ const ADD_BYPASS_ADMIN_HEADER =
 
 export const handler: Handler = (event) =>
   new Promise((resolve) => {
-    // Build forwarded headers, preserving the original Host header
+    // Build forwarded headers. Upstream Qelos expects Host = public app domain (e.g. app.auto.qelos.io),
+    // not the raw API IP — use the visitor-facing host (case-insensitive headers; rawUrl fallback).
     const headers: Record<string, string> = {};
-    for (const [key, val] of Object.entries(event.headers)) {
-      if (val) headers[key] = val;
+    for (const [key, val] of Object.entries(event.headers ?? {})) {
+      if (val == null || val === "") continue;
+      if (Array.isArray(val)) {
+        headers[key] = val.join(", ");
+      } else if (typeof val === "string") {
+        headers[key] = val;
+      }
     }
-    headers["host"] = event.headers["host"] ?? PROXY_HOST;
+    headers["host"] = publicHostForUpstream(event);
     if (ADD_BYPASS_ADMIN_HEADER) {
       headers["x-bypass-admin"] = "true";
     }
@@ -86,3 +92,38 @@ export const handler: Handler = (event) =>
     if (body) proxyReq.write(body);
     proxyReq.end();
   });
+
+function publicHostForUpstream(event: {
+  headers: Record<string, string | string[] | undefined>;
+  rawUrl: string;
+}): string {
+  const forwarded = pickHeader(event.headers, "x-forwarded-host");
+  if (forwarded) {
+    return forwarded.split(",")[0].trim();
+  }
+  const h = pickHeader(event.headers, "host");
+  if (h) {
+    return h;
+  }
+  try {
+    return new URL(event.rawUrl).hostname;
+  } catch {
+    return PROXY_HOST;
+  }
+}
+
+function pickHeader(
+  headers: Record<string, string | string[] | undefined>,
+  name: string,
+): string | undefined {
+  const want = name.toLowerCase();
+  for (const [k, v] of Object.entries(headers)) {
+    if (k.toLowerCase() !== want) continue;
+    if (v == null) continue;
+    const s = Array.isArray(v) ? v[0] : v;
+    if (typeof s === "string" && s.length > 0) {
+      return s;
+    }
+  }
+  return undefined;
+}

package/index.js

@@ -42,8 +42,12 @@ module.exports = {
       inputs.api_url ?? process.env.QELOS_API_IP ?? DEFAULT_API_URL;
     const bypassAdmin =
       inputs.bypass_admin === true || inputs.bypass_admin === 'true';
-    const useFunctionProxy =
-      inputs.use_function_proxy === true || inputs.use_function_proxy === 'true';
+    const useCdnProxy =
+      inputs.use_cdn_proxy === true ||
+      inputs.use_cdn_proxy === 'true' ||
+      inputs.use_function_proxy === false ||
+      inputs.use_function_proxy === 'false';
+    const useFunctionProxy = !useCdnProxy;
 
     if (!netlifyConfig.build.environment) {
       netlifyConfig.build.environment = {};
@@ -100,9 +104,9 @@ module.exports = {
       process.env.QELOS_API_IP ??
       DEFAULT_API_URL;
     const mode =
-      netlifyConfig?.build?.environment?.QELOS_NETLIFY_PROXY_MODE === 'function'
-        ? 'function'
-        : 'cdn';
+      netlifyConfig?.build?.environment?.QELOS_NETLIFY_PROXY_MODE === 'cdn'
+        ? 'cdn'
+        : 'function';
     const changed = patchRedirects(publishDir, apiUrl, mode);
     console.log(
       `[@qelos/plugin-netlify-api] onPostBuild: ${changed ? 'patched' : 'unchanged'} ${path.join(publishDir, '_redirects')} (${mode})`,

package/manifest.yml

@@ -8,7 +8,11 @@ inputs:
     required: false
     description: "If true, the proxy adds header x-bypass-admin: true to every request (so admins are scoped as regular users)."
     default: false
-  - name: use_function_proxy
+  - name: use_cdn_proxy
     required: false
-    description: "If true, use the bundled serverless function instead of Netlify CDN proxy to api_url (default is CDN rewrite to origin/api/:splat)."
+    description: "If true, rewrite /api/* directly to api_url at the edge (no serverless function). Default is false — use the bundled qelos-api-proxy function so Host headers and bypass_admin work."
     default: false
+  - name: use_function_proxy
+    required: false
+    description: "Deprecated alias: set false to get CDN direct-to-IP behavior (same as use_cdn_proxy true)."
+    default: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qelos/plugin-netlify-api",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "Netlify build plugin: proxy /api/* to Qelos API and inject config",
   "main": "index.js",
   "bin": {

package/scripts/patch-redirects.cjs

@@ -6,8 +6,8 @@
  * Netlify evaluates this file before netlify.toml; Nuxt `netlify-static` adds
  * `/* → /404.html` — that must come after `/api/*`.
  *
- * Default: CDN proxy to `${QELOS_API_IP}/api/:splat` (Netlify’s documented pattern).
- * Set QELOS_NETLIFY_PROXY_MODE=function to use the serverless function instead.
+ * Default: serverless function `/.netlify/functions/qelos-api-proxy` (QELOS_NETLIFY_PROXY_MODE unset or `function`).
+ * Set QELOS_NETLIFY_PROXY_MODE=cdn for edge direct-to-IP (no function).
  */
 
 const fs = require('node:fs');
@@ -88,7 +88,7 @@ function resolvePublishDirFromEnv() {
 if (require.main === module) {
   const abs = resolvePublishDirFromEnv();
   const mode =
-    process.env.QELOS_NETLIFY_PROXY_MODE === 'function' ? 'function' : 'cdn';
+    process.env.QELOS_NETLIFY_PROXY_MODE === 'cdn' ? 'cdn' : 'function';
   const apiUrl = process.env.QELOS_API_IP;
   const changed = patchRedirects(abs, apiUrl, mode);
   const target = path.join(abs, '_redirects');