@smartbit4all/ng-client 4.5.8 → 4.5.10

package/lib/session/smart-backend-bootstrap.config.d.ts

@@ -1,6 +1,25 @@
 import { UiActionDescriptor } from '../view-context/api';
 import { SmartViewHandlerModel } from '../view-context/smart-view-context.model';
 import { SessionError } from './smart-session-handler.service';
+/**
+ * Externally provided session + viewContext to hydrate the bootstrap with,
+ * bypassing the regular `start()` flow. Typical use case: a native mobile
+ * shell that performed authentication itself and hands off the result to a
+ * webview-hosted Angular app via URL fragment.
+ */
+export interface SmartBackendBootstrapCredentials {
+    /** SID issued by the backend; will be sent as `Authorization: Bearer <sessionToken>`. */
+    sessionToken: string;
+    /** UUID of an already-existing viewContext on the backend. */
+    viewContextUuid: string;
+    /**
+     * Optional long-lived refresh token paired with the SID. If provided, it is
+     * persisted to localStorage so the autonomous `SmartErrorCatchingInterceptor`
+     * REFRESH flow can recover from `session.expired` errors without dropping
+     * the user back to a fresh anonymous session.
+     */
+    refreshToken?: string;
+}
 export interface SmartBackendBootstrapConfig {
     url: string;
     cookieName: string;
@@ -13,4 +32,18 @@ export interface SmartBackendBootstrapConfig {
     onSmartLink?: (channel: string) => Promise<void> | void;
     /** Hook for host UX when `start()` rejects (snackbar + retry). */
     onStartError?: (err: unknown) => Promise<void> | void;
+    /**
+     * Hook called when the backend reports the current viewContext is gone
+     * (logout, session expiry, backend restart) — i.e. when the
+     * `SmartErrorCatchingInterceptor` would historically auto-trigger
+     * `RESTART_VIEWCONTEXT`.
+     *
+     * Default: rebuilds a fresh anonymous viewContext via
+     * `viewContext.initNewViewContext()` (the historical web flow).
+     *
+     * Mobile/embedded hosts override this to fully delegate to the shell —
+     * typically by calling a JS bridge that signals the native side to
+     * tear down the webview and return to the native login page.
+     */
+    onViewContextLost?: (err: SessionError) => Promise<void> | void;
 }

package/lib/session/smart-backend-bootstrap.service.d.ts

@@ -1,7 +1,7 @@
 import { SmartSessionService } from './smart-session.service';
 import { SmartViewContextService } from '../view-context/smart-view-context.service';
 import { SessionError, SmartSessionHandlerService } from './smart-session-handler.service';
-import { SmartBackendBootstrapConfig } from './smart-backend-bootstrap.config';
+import { SmartBackendBootstrapConfig, SmartBackendBootstrapCredentials } from './smart-backend-bootstrap.config';
 import * as i0 from "@angular/core";
 export declare class SmartBackendBootstrapService implements SmartSessionHandlerService {
     private session;
@@ -9,13 +9,26 @@ export declare class SmartBackendBootstrapService implements SmartSessionHandler
     private config?;
     private runningInit?;
     private lastInitFailed;
+    private mode?;
+    private runningViewContextLost?;
     constructor(session: SmartSessionService, viewContext: SmartViewContextService);
     configure(config: SmartBackendBootstrapConfig): void;
     private handleSmartLink;
     start(): Promise<void>;
+    bootstrapWith(creds: SmartBackendBootstrapCredentials): Promise<void>;
     whenReady(): Promise<void>;
     reset(): Promise<void>;
+    /**
+     * Called by `SmartErrorCatchingInterceptor` when the backend reports
+     * `session.viewcontext.missing`. Idempotent across concurrent and
+     * sequential calls until the next `reset()` — multiple racing BFF
+     * failures collapse into a single recovery attempt.
+     */
+    handleViewContextLost(err: SessionError): Promise<void>;
+    private runViewContextLost;
     private runInit;
+    private runBootstrapWith;
+    private handleInitFailure;
     handleSessionError(err: SessionError): Promise<void>;
     static ɵfac: i0.ɵɵFactoryDeclaration<SmartBackendBootstrapService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<SmartBackendBootstrapService>;

package/lib/session/smart-error-catching.interceptor.d.ts

@@ -1,13 +1,13 @@
 import { HttpEvent, HttpHandler, HttpInterceptor, HttpRequest } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { SessionError, SmartSessionService } from './projects';
-import { SmartViewContextService } from '../view-context/smart-view-context.service';
+import { SmartBackendBootstrapService } from './smart-backend-bootstrap.service';
 import * as i0 from "@angular/core";
 export declare class SmartErrorCatchingInterceptor implements HttpInterceptor {
     private session;
-    private viewcontext;
+    private bootstrap;
     sessionErrorCodes: SessionError[];
-    constructor(session: SmartSessionService, viewcontext: SmartViewContextService);
+    constructor(session: SmartSessionService, bootstrap: SmartBackendBootstrapService);
     intercept(request: HttpRequest<unknown>, next: HttpHandler): Observable<HttpEvent<unknown>>;
     private handleError;
     private isSessionError;

package/lib/session/smart-session.service.d.ts

@@ -33,6 +33,19 @@ export declare class SmartSessionService implements OnDestroy {
     handleSessionError(sessionError: SessionError): Promise<void>;
     addHeaderParam(headerParam: HeaderParam): void;
     private setUpTokenForSessionService;
+    /**
+     * Hydrates the session with an externally obtained SID, bypassing
+     * `initialize()`'s backend round-trip. Used by the
+     * `SmartBackendBootstrapService.bootstrapWith()` flow when a host
+     * (e.g. native mobile shell) hands over an already-authenticated session.
+     *
+     * Persists the SID to localStorage + cookie so that a page reload can
+     * rehydrate the session through `initialize()`'s regular
+     * `tokenFromLocalStorage === tokenFromCookies` path. The optional
+     * refreshToken is persisted to enable autonomous refresh via
+     * `refreshSession()` when the SID expires.
+     */
+    setSessionToken(token: string, refreshToken?: string): void;
     setUrl(url: string): void;
     getBasePath(): string;
     setCookieName(name: string): void;

package/lib/view-context/smart-view-context.service.d.ts

@@ -82,6 +82,14 @@ export declare class SmartViewContextService implements OnDestroy {
     startViewContext(): Promise<ViewContextData>;
     initialize(uuid?: string): Promise<ViewContextData | undefined>;
     initViewContext(): Promise<void>;
+    /**
+     * Hydrates the view-context state from an already-existing UUID provided
+     * externally (e.g. by a native mobile shell via URL fragment). Unlike
+     * `initialize(uuid)`, this method does NOT fall back to creating a fresh
+     * viewContext if the backend rejects the UUID — the caller is expected to
+     * surface the failure (typically via the bootstrap's `onStartError` hook).
+     */
+    initFromExistingViewContext(uuid: string): Promise<void>;
     initNewViewContext(): Promise<void>;
     openView(view: ViewData): ViewStateUpdate | undefined;
     closeView(view: ViewData): ViewStateUpdate[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartbit4all/ng-client",
-  "version": "4.5.8",
+  "version": "4.5.10",
   "peerDependencies": {
     "@angular/animations": "^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0",
     "@angular/common": "^13.0.0 || ^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0",