@efa-one/sdk 1.17.0 → 1.18.0

package/README.md

@@ -61,6 +61,24 @@ import { initI18n, registerAppInfo, DevHeader } from '@efa-one/sdk/frontend';
 registerAppInfo({ appName: 'efa-chat', version: __APP_VERSION__ });
 ```
 
+```tsx
+// Frontend — receive the login token from the kernel (inside a mount effect)
+import { subscribeConvergeAuth } from '@efa-one/sdk/frontend';
+
+useEffect(() => subscribeConvergeAuth({
+  onAuth: async ({ token, serviceKey, theme, language }) => {
+    try { await exchange(token, serviceKey); return true; } catch { return false; }
+  },
+  onTimeout: () => setError('No login received from the platform — reload the page.'),
+}), []);
+```
+
+The app asks for the token itself (`CONVERGE_AUTH_REQUEST`) as soon as its listener
+is attached and repeats the request with backoff. Waiting passively for the kernel's
+push is not enough: the push goes out in a fixed window after the tile opens, and an
+app that needs longer to mount (cold cache, slow connection) would miss it and spin
+forever.
+
 ```tsx
 // Frontend — a fully-featured list in a few lines
 import { DataTable, type ColumnDef } from '@efa-one/sdk/frontend/ui';
@@ -152,6 +170,11 @@ kernel without that endpoint, every authenticated request fails closed with
 Sessions issued by an older SDK are rejected once (401) and renewed on the next
 iframe load.
 
+**1.18.0 — auth handshake on request.** `subscribeConvergeAuth` sends
+`CONVERGE_AUTH_REQUEST` to the kernel. It works against any kernel: an older kernel
+ignores the request and its fixed-window push reaches the app as before; a current
+kernel answers the request directly. No rollout order.
+
 ## License
 
 [Apache-2.0](./LICENSE) — permissive with a patent grant, so customers and partners

package/frontend/ipc.d.ts

@@ -24,3 +24,22 @@ export declare function navigateToApp(serviceKey: string, options?: {
     path?: string;
 }): void;
 export declare function notifyRouteChange(path: string): void;
+export declare const CONVERGE_AUTH = "CONVERGE_AUTH";
+export declare const CONVERGE_AUTH_REQUEST = "CONVERGE_AUTH_REQUEST";
+export interface ConvergeAuthMessage<TTheme = unknown> {
+    type: typeof CONVERGE_AUTH;
+    token: string;
+    serviceKey?: string;
+    language?: string;
+    theme?: TTheme;
+    embed?: boolean;
+}
+export interface SubscribeConvergeAuthOptions<TTheme = unknown> {
+    onAuth: (message: ConvergeAuthMessage<TTheme>) => Promise<boolean>;
+    onTimeout?: () => void;
+    requestDelaysMs?: readonly number[];
+    timeoutMs?: number;
+}
+export declare const DEFAULT_AUTH_REQUEST_DELAYS_MS: readonly number[];
+export declare const DEFAULT_AUTH_TIMEOUT_MS = 15000;
+export declare function subscribeConvergeAuth<TTheme = unknown>(options: SubscribeConvergeAuthOptions<TTheme>): () => void;

package/frontend/ipc.js

@@ -59,3 +59,82 @@ export function notifyRouteChange(path) {
         return;
     window.parent.postMessage({ type: 'CONVERGE_ROUTE_CHANGED', path }, getParentOrigin());
 }
+export const CONVERGE_AUTH = 'CONVERGE_AUTH';
+export const CONVERGE_AUTH_REQUEST = 'CONVERGE_AUTH_REQUEST';
+export const DEFAULT_AUTH_REQUEST_DELAYS_MS = [0, 500, 1000, 2000, 4000, 8000];
+export const DEFAULT_AUTH_TIMEOUT_MS = 15000;
+function isAuthMessage(data) {
+    const d = data;
+    return !!d && d.type === CONVERGE_AUTH && typeof d.token === 'string' && d.token !== '';
+}
+export function subscribeConvergeAuth(options) {
+    if (!isEmbedded())
+        return () => { };
+    const delays = options.requestDelaysMs ?? DEFAULT_AUTH_REQUEST_DELAYS_MS;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_AUTH_TIMEOUT_MS;
+    let active = true;
+    let received = false;
+    let authenticated = false;
+    let inFlight = false;
+    let queued = null;
+    const timers = [];
+    const clearTimers = () => {
+        timers.forEach((t) => clearTimeout(t));
+        timers.length = 0;
+    };
+    const start = (message) => {
+        inFlight = true;
+        options.onAuth(message).then((ok) => finish(ok), () => finish(false));
+    };
+    const finish = (ok) => {
+        inFlight = false;
+        if (!active)
+            return;
+        if (ok) {
+            authenticated = true;
+            queued = null;
+            clearTimers();
+            return;
+        }
+        const next = queued;
+        queued = null;
+        if (next)
+            start(next);
+    };
+    const handler = (event) => {
+        if (!isFromPlatformParent(event))
+            return;
+        if (!isAuthMessage(event.data))
+            return;
+        received = true;
+        if (authenticated)
+            return;
+        const message = event.data;
+        if (inFlight) {
+            queued = message;
+            return;
+        }
+        start(message);
+    };
+    const request = () => {
+        if (!active || received)
+            return;
+        window.parent.postMessage({ type: CONVERGE_AUTH_REQUEST }, getParentOrigin());
+    };
+    window.addEventListener('message', handler);
+    for (const ms of delays) {
+        if (ms <= 0)
+            request();
+        else
+            timers.push(setTimeout(request, ms));
+    }
+    timers.push(setTimeout(() => {
+        if (active && !received)
+            options.onTimeout?.();
+    }, timeoutMs));
+    return () => {
+        active = false;
+        clearTimers();
+        window.removeEventListener('message', handler);
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@efa-one/sdk",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "Offizielles SDK für efa-one-Apps: Auth/Session, Service-Discovery, Gateway-Client, Audit/Reporting/Mail/Notifications, Permission- und Capability-Registrierung sowie das Frontend-IPC-/i18n-Toolkit.",
   "license": "Apache-2.0",
   "type": "commonjs",