keystone-design-bootstrap 1.0.103 → 1.0.105-dev.0

package/src/next/routes/chat.ts

@@ -5,13 +5,27 @@
  *   // app/api/chat/route.ts
  *   export { GET, POST } from 'keystone-design-bootstrap/next/routes/chat';
  *
- * Supports both anonymous (session-based) and authenticated (contact-driven) flows.
- * Both flows hit the same backend endpoint (`/public/messages`); the discriminator
- * is whether `identifier` (session string) or `contact_id` (integer) is supplied.
+ * Supports TWO backends, selected per site (default: 'rails', so existing
+ * consumers are unaffected):
+ *
+ *   createChatRouteHandlers({ backend: 'sor' })   // explicit option
+ *   CHAT_BACKEND=sor                              // env override
+ *   (otherwise derived from API_URL — a `sor` hostname label ⇒ 'sor';
+ *    see lib/chat-backend.ts)
+ *
+ * - 'rails' (keystone-mono-proto): anonymous (`identifier`) and authenticated
+ *   (`contact_id`) flows against `/public/messages`, plus the
+ *   `action=realtime_token` + `cable_url` flow that feeds ActionCable.
+ * - 'sor' (sor-service): anonymous webchat against `/public/chat/*` —
+ *   `session_id` (first-party cookie) + `{ messages, cursor }`, translated to
+ *   the widget's existing wire shape. No realtime; the widget's polling
+ *   fallback covers reply delivery. The `realtime_token` action returns an
+ *   empty payload (no `cable_url`) so the widget knows realtime is unavailable.
  *
  * Env (server-side only):
- * - API_URL (default: http://localhost:3000/api/v1)
- * - API_KEY
+ * - API_URL (default: http://localhost:3000/api/v1) — backend base, includes /api/v1
+ * - API_KEY                                          — business public key (X-API-Key)
+ * - CHAT_BACKEND ('rails' | 'sor', default 'rails')
  */
 
 // IMPORTANT:
@@ -23,28 +37,31 @@
 
 import { clientContextHeaders } from './proxy-headers';
 import { serverError } from '../../lib/server-log';
+import { resolveChatBackend, SOR_BACKEND, type ChatBackend } from '../../lib/chat-backend';
 
 const API_URL = process.env.API_URL || 'http://localhost:3000/api/v1';
 const API_KEY = process.env.API_KEY || '';
 const CONSUMER_TOKEN_COOKIE = 'ks_consumer_token';
+const SESSION_COOKIE = 'ks_chat_session';
+
+export type { ChatBackend };
 
 type JsonResponder = (body: unknown, init?: ResponseInit) => Response;
 
-function cookieValue(cookieHeader: string | null, key: string): string | null {
-  if (!cookieHeader) return null;
-  const token = cookieHeader
-    .split(';')
-    .map((part) => part.trim())
-    .find((part) => part.startsWith(`${key}=`))
-    ?.split('=')
-    .slice(1)
-    .join('=');
-  return token ? decodeURIComponent(token) : null;
+function readCookie(request: Request, name: string): string | null {
+  const header = request.headers.get('cookie') || '';
+  for (const part of header.split(';')) {
+    const [k, ...v] = part.trim().split('=');
+    if (k === name) return decodeURIComponent(v.join('='));
+  }
+  return null;
 }
 
-export function createChatRouteHandlers(deps?: { NextResponse?: { json: JsonResponder } }) {
-  const json: JsonResponder = deps?.NextResponse?.json ?? ((body, init) => Response.json(body, init));
+/* ------------------------------------------------------------------------ *
+ * rails backend (keystone-mono-proto)
+ * ------------------------------------------------------------------------ */
 
+function createRailsHandlers(json: JsonResponder) {
   return {
     // POST /api/chat — send a message (session-based or contact-driven)
     POST: async (request: Request): Promise<Response> => {
@@ -103,7 +120,7 @@ export function createChatRouteHandlers(deps?: { NextResponse?: { json: JsonResp
 
           const response = contactId
             ? await (async () => {
-                const consumerToken = cookieValue(request.headers.get('cookie'), CONSUMER_TOKEN_COOKIE);
+                const consumerToken = readCookie(request, CONSUMER_TOKEN_COOKIE);
                 if (!consumerToken) {
                   return new Response(JSON.stringify({ error: 'Unauthorized' }), {
                     status: 401,
@@ -163,3 +180,183 @@ export function createChatRouteHandlers(deps?: { NextResponse?: { json: JsonResp
     },
   };
 }
+
+/* ------------------------------------------------------------------------ *
+ * sor backend (sor-service)
+ * ------------------------------------------------------------------------ */
+
+/**
+ * Real browser signals to forward upstream. sor-service reads the visitor IP
+ * from X-Forwarded-For, the user-agent from User-Agent, and fbp/fbc from the
+ * POST body — so we set the headers and return fbp/fbc for the body.
+ */
+function clientContext(request: Request): {
+  headers: Record<string, string>;
+  fbp?: string;
+  fbc?: string;
+} {
+  const ip =
+    request.headers.get('x-real-ip') ||
+    request.headers.get('x-forwarded-for')?.split(',')[0]?.trim();
+  const ua = request.headers.get('user-agent') || undefined;
+  const headers: Record<string, string> = {};
+  if (ip) headers['X-Forwarded-For'] = ip;
+  if (ua) headers['User-Agent'] = ua;
+  return {
+    headers,
+    fbp: readCookie(request, '_fbp') || undefined,
+    fbc: readCookie(request, '_fbc') || undefined,
+  };
+}
+
+function sessionCookieHeader(sessionId: string): string {
+  // First-party (set by the site's own origin via this proxy), so it survives
+  // third-party-cookie blocking. 1-year, lax, http-only.
+  return `${SESSION_COOKIE}=${encodeURIComponent(sessionId)}; Path=/; Max-Age=31536000; SameSite=Lax; HttpOnly`;
+}
+
+interface SorMessage {
+  id: string;
+  direction?: string;
+  sender_type?: string;
+  body?: string | null;
+  created_at?: string | null;
+}
+
+/** Translate a sor-service message to the widget's flat shape. */
+function toWidgetMessage(m: SorMessage) {
+  const isAgent = m.direction === 'OUTBOUND' || (!!m.sender_type && m.sender_type !== 'CONSUMER');
+  return {
+    id: m.id,
+    body: m.body ?? '',
+    sender_type: isAgent ? 'agent' : 'contact',
+    sender_display_name: isAgent ? 'Assistant' : 'You',
+    created_at: m.created_at ?? new Date().toISOString(),
+  };
+}
+
+function createSorHandlers(json: JsonResponder) {
+  return {
+    // POST /api/chat — send a message (anonymous session flow)
+    POST: async (request: Request): Promise<Response> => {
+      try {
+        const body = await request.json();
+        const {
+          identifier,
+          session_id,
+          body: messageBody,
+          display_name,
+          email,
+          phone,
+          first_name,
+          last_name,
+          page_url,
+        } = body;
+
+        if (!messageBody || !String(messageBody).trim()) {
+          return json({ success: false, error: 'Message body is required.' }, { status: 400 });
+        }
+        const sessionId = identifier || session_id || readCookie(request, SESSION_COOKIE);
+        if (!sessionId) {
+          return json({ success: false, error: 'identifier (session) is required.' }, { status: 400 });
+        }
+
+        const ctx = clientContext(request);
+        const response = await fetch(`${API_URL}/public/chat/messages`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'X-API-Key': API_KEY,
+            ...ctx.headers,
+          },
+          body: JSON.stringify({
+            session_id: sessionId,
+            body: messageBody,
+            display_name,
+            email,
+            phone,
+            first_name,
+            last_name,
+            page_url,
+            fbp: ctx.fbp,
+            fbc: ctx.fbc,
+          }),
+        });
+
+        const data = await response.json().catch(() => ({}));
+        if (!response.ok) {
+          return json(
+            { success: false, error: data?.message || 'Failed to send message. Please try again.' },
+            { status: response.status }
+          );
+        }
+
+        // Return a truthy `job_id` so the widget long-polls for the async AI
+        // reply — sentinel fallback because a falsy job_id would silently skip
+        // the reply wait (sor always dispatches the AI async).
+        const cursor = data?.data?.cursor ?? null;
+        return json(
+          { success: true, data: { job_id: cursor ?? 'pending', cursor } },
+          { headers: { 'Set-Cookie': sessionCookieHeader(sessionId) } }
+        );
+      } catch (error) {
+        serverError('CHAT_ROUTE_POST_ERROR', error);
+        return json({ success: false, error: 'Network error. Please try again later.' }, { status: 500 });
+      }
+    },
+
+    // GET /api/chat?identifier=... — load message history (flat array, widget shape)
+    GET: async (request: Request): Promise<Response> => {
+      try {
+        const { searchParams } = new URL(request.url);
+
+        // No ActionCable on sor-service: answer the widget's realtime probe with
+        // an empty payload (no cable_url) so it falls back to polling.
+        if (searchParams.get('action') === 'realtime_token') {
+          return json({ success: true, data: {} });
+        }
+
+        const sessionId =
+          searchParams.get('identifier') ||
+          searchParams.get('session_id') ||
+          readCookie(request, SESSION_COOKIE);
+
+        if (!sessionId) {
+          return json({ success: true, data: [] });
+        }
+
+        const query = new URLSearchParams({ session_id: sessionId, wait: '0' });
+        const since = searchParams.get('since');
+        if (since) query.set('since', since);
+
+        const response = await fetch(`${API_URL}/public/chat/messages?${query.toString()}`, {
+          headers: { 'X-API-Key': API_KEY },
+        });
+
+        const data = await response.json().catch(() => ({}));
+        if (!response.ok) {
+          return json(
+            { success: false, error: data?.message || 'Failed to load messages.' },
+            { status: response.status }
+          );
+        }
+
+        const messages = (data?.data?.messages ?? []) as SorMessage[];
+        return json({ success: true, data: messages.map(toWidgetMessage) });
+      } catch (error) {
+        serverError('CHAT_ROUTE_GET_ERROR', error);
+        return json({ success: false, error: 'Network error. Please try again later.' }, { status: 500 });
+      }
+    },
+  };
+}
+
+export function createChatRouteHandlers(deps?: {
+  NextResponse?: { json: JsonResponder };
+  backend?: ChatBackend;
+}) {
+  const json: JsonResponder = deps?.NextResponse?.json ?? ((body, init) => Response.json(body, init));
+  const backend: ChatBackend = deps?.backend ?? resolveChatBackend();
+
+  return backend === SOR_BACKEND ? createSorHandlers(json) : createRailsHandlers(json);
+}

package/src/next/routes/consumer-auth.ts

@@ -11,9 +11,9 @@
  *
  * Env (server-side only):
  * - API_URL (default: http://localhost:3000/api/v1)
+ * - AUTH_API_URL (optional) — overrides API_URL for consumer auth/session endpoints.
+ *   Set this when auth lives on a separate service (e.g. Heimdal) from the data API.
  * - API_KEY
- * - CONSUMER_AUTH_URL (optional; overrides passwordless routes base, e.g.
- *   https://www.keystone.app/api/consumer)
  */
 
 import { CONSUMER_TOKEN_COOKIE } from '../../lib/consumer-session';
@@ -25,19 +25,13 @@ type NextResponseLike = { json: (body: unknown, init?: ResponseInit) => any };
 const COOKIE_MAX_AGE = 60 * 60 * 24 * 30; // 30 days
 
 function getApiUrl(): string {
-  return process.env.API_URL || 'http://localhost:3000/api/v1';
+  return process.env.AUTH_API_URL || process.env.API_URL || 'http://localhost:3000/api/v1';
 }
 
 function getApiKey(): string {
   return process.env.API_KEY || '';
 }
 
-function getPasswordlessBaseUrl(): string {
-  const override = (process.env.CONSUMER_AUTH_URL || '').trim();
-  if (override) return override.replace(/\/+$/, '');
-  return `${getApiUrl().replace(/\/+$/, '')}/consumer/auth`;
-}
-
 function apiHeaders(request?: Request): Record<string, string> {
   const key = getApiKey();
   return {
@@ -47,69 +41,22 @@ function apiHeaders(request?: Request): Record<string, string> {
   };
 }
 
-function responseData(json: Record<string, unknown>): Record<string, unknown> {
-  return (json.data as Record<string, unknown>) || json;
-}
-
-function readStringField(obj: Record<string, unknown>, key: string): string | null {
-  const value = obj[key];
-  return typeof value === 'string' && value.length > 0 ? value : null;
-}
-
-function readNestedStringField(
-  obj: Record<string, unknown>,
-  parentKey: string,
-  key: string
-): string | null {
-  const parent = obj[parentKey];
-  if (!parent || typeof parent !== 'object') return null;
-  const value = (parent as Record<string, unknown>)[key];
-  return typeof value === 'string' && value.length > 0 ? value : null;
+function asString(value: unknown): string | undefined {
+  return typeof value === 'string' && value ? value : undefined;
 }
 
-function extractAuthToken(data: Record<string, unknown>): string | null {
-  const direct =
-    readStringField(data, 'token') ||
-    readStringField(data, 'auth_token') ||
-    readStringField(data, 'access_token') ||
-    readStringField(data, 'session_token') ||
-    readStringField(data, 'jwt') ||
-    readNestedStringField(data, 'consumer', 'token') ||
-    readNestedStringField(data, 'session', 'token');
-  if (direct) return direct;
-
-  // Compatibility fallback: some backends rename token fields without notice.
-  // Walk a few levels and accept any non-empty string on keys containing "token"/"jwt".
-  const queue: Array<{ value: unknown; depth: number }> = [{ value: data, depth: 0 }];
-  const visited = new Set<object>();
-  while (queue.length > 0) {
-    const next = queue.shift();
-    if (!next) break;
-    const { value, depth } = next;
-    if (!value || typeof value !== 'object') continue;
-    if (visited.has(value as object)) continue;
-    visited.add(value as object);
-
-    const entries = Object.entries(value as Record<string, unknown>);
-    for (const [key, candidate] of entries) {
-      // Never treat verification tokens as auth/session JWTs.
-      if (/verification[_-]?token/i.test(key)) {
-        if (depth < 4 && candidate && typeof candidate === 'object') {
-          queue.push({ value: candidate, depth: depth + 1 });
-        }
-        continue;
-      }
-      const isTokenLikeKey = /token|jwt/i.test(key);
-      if (isTokenLikeKey && typeof candidate === 'string' && candidate.length > 0) {
-        return candidate;
-      }
-      if (depth < 4 && candidate && typeof candidate === 'object') {
-        queue.push({ value: candidate, depth: depth + 1 });
-      }
-    }
-  }
-
-  return null;
+// Rails returns errors at the top level ({ error, code }); FastAPI backends
+// (Heimdal) nest them under `detail`, where `error` is either a string or a
+// { code, message } object for validation failures. Read all shapes, but only
+// ever surface strings.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function upstreamError(json: any): { error?: string; code?: string; retry_in_seconds?: number } {
+  const err = json.error ?? json.detail?.error;
+  return {
+    error: asString(err) || asString(err?.message),
+    code: asString(json.code) || asString(json.detail?.code) || asString(err?.code),
+    retry_in_seconds: json.retry_in_seconds ?? json.detail?.retry_in_seconds,
+  };
 }
 
 // POST /api/consumer/initiate
@@ -133,8 +80,8 @@ async function handleInitiate(request: Request, NR: NextResponseLike): Promise<R
     if (res.status === 404) return NR.json({ exists: false });
     if (!res.ok) return NR.json({ exists: null });
 
-    const json = await res.json().catch(() => ({})) as Record<string, unknown>;
-    const data = responseData(json);
+    const json = await res.json().catch(() => ({}));
+    const data = json.data as Record<string, unknown> | undefined;
     return NR.json({
       exists: true,
       firstName: data?.first_name ?? undefined,
@@ -163,14 +110,14 @@ async function handleLogin(request: Request, NR: NextResponseLike): Promise<Resp
 
   const json = await res.json().catch(() => ({}));
   if (!res.ok) {
+    const err = upstreamError(json);
     return NR.json(
-      { error: json.error || 'Login failed. Please try again.', code: json.code },
+      { error: err.error || 'Login failed. Please try again.', code: err.code },
       { status: res.status }
     );
   }
 
-  const data = responseData(json);
-  const token = extractAuthToken(data);
+  const token = json.data?.token;
   if (!token) return NR.json({ error: 'No token received.' }, { status: 500 });
 
   const response = NR.json({});
@@ -206,16 +153,18 @@ async function handleSignup(request: Request, NR: NextResponseLike): Promise<Res
     }),
   });
 
-  const json = await res.json().catch(() => ({})) as Record<string, unknown>;
+  const json = await res.json().catch(() => ({}));
   if (!res.ok) {
-    return NR.json({ error: json.error || 'Signup failed. Please try again.' }, { status: res.status });
+    return NR.json(
+      { error: upstreamError(json).error || 'Signup failed. Please try again.' },
+      { status: res.status }
+    );
   }
 
-  const data = responseData(json);
-  const token = extractAuthToken(data);
+  const token = json.data?.token;
   if (!token) return NR.json({ error: 'No token received.' }, { status: 500 });
 
-  const response = NR.json({ claimed: data?.claimed ?? false });
+  const response = NR.json({ claimed: json.data?.claimed ?? false });
   response.cookies.set(CONSUMER_TOKEN_COOKIE, token, {
     httpOnly: true,
     secure: process.env.NODE_ENV === 'production',
@@ -233,27 +182,27 @@ async function handleSendCode(request: Request, NR: NextResponseLike): Promise<R
   const { phone } = body;
   if (!phone) return NR.json({ error: 'Phone is required.' }, { status: 422 });
 
-  const res = await fetch(`${getPasswordlessBaseUrl()}/send_code`, {
+  const res = await fetch(`${getApiUrl()}/consumer/auth/send_code`, {
     method: 'POST',
     headers: apiHeaders(request),
     body: JSON.stringify({ phone }),
   });
 
-  const json = await res.json().catch(() => ({})) as Record<string, unknown>;
-  const data = responseData(json);
+  const json = await res.json().catch(() => ({}));
   if (!res.ok) {
+    const err = upstreamError(json);
     return NR.json(
       {
-        error: (json as Record<string, unknown>).error || 'Failed to send verification code. Please try again.',
-        code: (json as Record<string, unknown>).code,
-        retry_in_seconds: (json as Record<string, unknown>).retry_in_seconds,
+        error: err.error || 'Failed to send verification code. Please try again.',
+        code: err.code,
+        retry_in_seconds: err.retry_in_seconds,
       },
       { status: res.status }
     );
   }
 
   return NR.json({
-    resend_available_at: data?.resend_available_at ?? null,
+    resend_available_at: json.data?.resend_available_at ?? null,
   });
 }
 
@@ -264,49 +213,26 @@ async function handleVerifyCode(request: Request, NR: NextResponseLike): Promise
   const { phone, code } = body;
   if (!phone || !code) return NR.json({ error: 'Phone and code are required.' }, { status: 422 });
 
-  const res = await fetch(`${getPasswordlessBaseUrl()}/verify_code`, {
+  const res = await fetch(`${getApiUrl()}/consumer/auth/verify_code`, {
     method: 'POST',
     headers: apiHeaders(request),
     body: JSON.stringify({ phone, code }),
   });
 
-  const json = await res.json().catch(() => ({})) as Record<string, unknown>;
-  const data = responseData(json);
+  const json = await res.json().catch(() => ({}));
   if (!res.ok) {
+    const err = upstreamError(json);
     return NR.json(
-      {
-        error: (json as Record<string, unknown>).error || 'Verification failed. Please try again.',
-        code: (json as Record<string, unknown>).code,
-      },
+      { error: err.error || 'Verification failed. Please try again.', code: err.code },
       { status: res.status }
     );
   }
 
-  // Some surfaces return a direct session token on verify.
-  const directToken = extractAuthToken(data);
-  if (directToken) {
-    const response = NR.json({
-      authenticated: true,
-      first_name: data?.first_name ?? '',
-      last_name: data?.last_name ?? '',
-      email: data?.email ?? '',
-      eventId: data?.event_id ?? undefined,
-    });
-    response.cookies.set(CONSUMER_TOKEN_COOKIE, directToken, {
-      httpOnly: true,
-      secure: process.env.NODE_ENV === 'production',
-      sameSite: 'lax',
-      path: '/',
-      maxAge: COOKIE_MAX_AGE,
-    });
-    return response;
-  }
-
   return NR.json({
-    verification_token: data?.verification_token,
-    first_name: data?.first_name ?? '',
-    last_name: data?.last_name ?? '',
-    email: data?.email ?? '',
+    verification_token: json.data?.verification_token,
+    first_name: json.data?.first_name ?? '',
+    last_name: json.data?.last_name ?? '',
+    email: json.data?.email ?? '',
   });
 }
 
@@ -322,7 +248,7 @@ async function handlePasswordlessAuth(request: Request, NR: NextResponseLike): P
     return NR.json({ error: 'First name, last name, and email are required.' }, { status: 422 });
   }
 
-  const res = await fetch(`${getPasswordlessBaseUrl()}/passwordless_auth`, {
+  const res = await fetch(`${getApiUrl()}/consumer/auth/passwordless_auth`, {
     method: 'POST',
     headers: apiHeaders(request),
     body: JSON.stringify({
@@ -334,21 +260,20 @@ async function handlePasswordlessAuth(request: Request, NR: NextResponseLike): P
     }),
   });
 
-  const json = await res.json().catch(() => ({})) as Record<string, unknown>;
-  const data = responseData(json);
+  const json = await res.json().catch(() => ({}));
   if (!res.ok) {
     return NR.json(
-      { error: (json as Record<string, unknown>).error || 'Authentication failed. Please try again.' },
+      { error: upstreamError(json).error || 'Authentication failed. Please try again.' },
       { status: res.status }
     );
   }
 
-  const token = extractAuthToken(data);
+  const token = json.data?.token;
   if (!token) return NR.json({ error: 'No token received.' }, { status: 500 });
 
   // Surface the server-side Lead event_id so the browser can fire a single deduped
   // Lead (fbq track with { eventID }) that Meta matches against the CAPI Lead event.
-  const response = NR.json({ eventId: data?.event_id ?? undefined });
+  const response = NR.json({ eventId: json.data?.event_id ?? undefined });
   response.cookies.set(CONSUMER_TOKEN_COOKIE, token, {
     httpOnly: true,
     secure: process.env.NODE_ENV === 'production',