@nebulr-group/bridge-svelte 0.2.0 → 0.3.0-beta.0

package/dist/auth/route-guard.d.ts

@@ -1,32 +1,2 @@
-export type PublicRoutePattern = string | RegExp;
-export type FlagRequirement = string | {
-    any: string[];
-} | {
-    all: string[];
-};
-export type RouteRule = {
-    match: string | RegExp;
-    public?: boolean;
-    featureFlag?: FlagRequirement;
-    redirectTo?: string;
-};
-export interface RouteGuardConfig {
-    rules: RouteRule[];
-    defaultAccess?: 'public' | 'protected';
-}
-export declare function createRouteGuard(): {
-    isPublicRoute: (pathname: string) => boolean;
-    isProtectedRoute: (pathname: string) => boolean;
-    shouldRedirectToLogin: (pathname: string) => boolean;
-    checkRouteRestrictions: (pathname: string) => Promise<string | null>;
-    getLoginRedirect: () => string;
-    getNavigationDecision(pathname: string): Promise<{
-        type: "allow";
-    } | {
-        type: "login";
-        loginUrl: string;
-    } | {
-        type: "redirect";
-        to: string;
-    }>;
-};
+export type { FlagRequirement, NavigationDecision, RouteGuard, RouteGuardConfig, RouteRule } from '@nebulr-group/bridge-auth-core';
+export declare function createRouteGuard(flagsReady?: Promise<void>): import("@nebulr-group/bridge-auth-core").RouteGuard;

package/dist/auth/route-guard.js

@@ -1,104 +1,24 @@
-import { get } from 'svelte/store';
+// src/lib/auth/route-guard.ts — thin wrapper delegating to auth-core via bridge-instance
+import { getBridgeAuth } from '../core/bridge-instance.js';
 import { getRouteGuardConfig } from '../client/stores/config.store.js';
-import { isFeatureEnabled } from '../shared/feature-flag.js';
-import { logger } from '../shared/logger.js';
-import { auth } from '../shared/services/auth.service.js';
-const { isAuthenticated, createLoginUrl } = auth;
-function escapeRegex(text) {
-    return text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-function toRegExp(pattern) {
-    if (pattern instanceof RegExp)
-        return pattern;
-    // Support simple wildcard '*'
-    const hasWildcard = pattern.includes('*');
-    if (!hasWildcard) {
-        return new RegExp(`^${escapeRegex(pattern)}$`);
-    }
-    const escaped = escapeRegex(pattern).replace(/\\\*/g, '.*');
-    return new RegExp(`^${escaped}$`);
-}
-function findMatchingRule(pathname, config) {
-    for (const rule of config.rules) {
-        if (toRegExp(rule.match).test(pathname)) {
-            return rule;
-        }
-    }
-    return null;
-}
-async function evaluateFlagRequirement(req) {
-    if (typeof req === 'string') {
-        return isFeatureEnabled(req);
-    }
-    if ('any' in req) {
-        const results = await Promise.all(req.any.map((f) => isFeatureEnabled(f)));
-        return results.some(Boolean);
-    }
-    if ('all' in req) {
-        const results = await Promise.all(req.all.map((f) => isFeatureEnabled(f)));
-        return results.every(Boolean);
-    }
-    return true;
-}
-export function createRouteGuard() {
+export function createRouteGuard(flagsReady) {
     const config = getRouteGuardConfig();
-    function isPublicRoute(pathname) {
-        const rule = findMatchingRule(pathname, config);
-        if (rule) {
-            logger.debug(`[route-guard] path ${pathname} is ${rule.public ? 'public' : 'protected'} by bridge rule ${rule.match}`);
-            return !!rule.public;
-        }
-        logger.debug(`[route-guard] path ${pathname} is ${config.defaultAccess === 'public' ? 'public' : 'protected'} by bridge default access ${config.defaultAccess}`);
-        const isPublicByDefault = (config.defaultAccess ?? 'protected') === 'public';
-        return isPublicByDefault;
-    }
-    function isProtectedRoute(pathname) {
-        return !isPublicRoute(pathname);
-    }
-    function shouldRedirectToLogin(pathname) {
-        const isProtected = isProtectedRoute(pathname);
-        const tokens = auth.getToken();
-        const authenticated = get(isAuthenticated);
-        logger.debug(`[route-guard] shouldRedirectToLogin check`, {
-            pathname,
-            isProtected,
-            hasTokens: !!tokens?.accessToken,
-            authenticated,
-            tokenStoreValue: tokens
-        });
-        if (isProtectedRoute(pathname) && !get(isAuthenticated)) {
-            logger.debug(`[route-guard] path ${pathname} is protected and user is not authenticated`);
-            return true;
-        }
-        logger.debug(`[route-guard] path ${pathname} is ${isProtected ? 'protected' : 'public'} and user ${authenticated ? 'authenticated' : 'not authenticated'}`);
-        return false;
-    }
-    async function checkRouteRestrictions(pathname) {
-        const rule = findMatchingRule(pathname, config);
-        if (!rule)
-            return null;
-        if (rule.featureFlag) {
-            const ok = await evaluateFlagRequirement(rule.featureFlag);
-            logger.debug(`[route-guard] path ${pathname} is restricted by bridge feature flag ${rule.featureFlag} and flag requirment evaluated to ${ok}`);
-            if (!ok)
-                return rule.redirectTo ?? '/';
-        }
-        return null;
-    }
-    function getLoginRedirect() {
-        return createLoginUrl();
-    }
+    const guard = getBridgeAuth().createRouteGuard(config);
+    if (!flagsReady)
+        return guard;
+    // Wrap checkRouteRestrictions to await flagsReady before evaluating
     return {
-        isPublicRoute,
-        isProtectedRoute,
-        shouldRedirectToLogin,
-        checkRouteRestrictions,
-        getLoginRedirect,
+        ...guard,
+        async checkRouteRestrictions(pathname) {
+            await flagsReady;
+            return guard.checkRouteRestrictions(pathname);
+        },
         async getNavigationDecision(pathname) {
-            if (shouldRedirectToLogin(pathname)) {
-                return { type: 'login', loginUrl: getLoginRedirect() };
+            if (guard.shouldRedirectToLogin(pathname)) {
+                return { type: 'login', loginUrl: guard.getLoginRedirect() };
             }
-            const redirectTo = await checkRouteRestrictions(pathname);
+            await flagsReady;
+            const redirectTo = await guard.checkRouteRestrictions(pathname);
             if (redirectTo) {
                 return { type: 'redirect', to: redirectTo };
             }

package/dist/client/BridgeBootstrap.d.ts

@@ -1,5 +1,8 @@
 import type { RouteGuardConfig } from '../auth/route-guard.js';
+import { waitForBridge as _waitForBridge } from '../core/bridge-instance.js';
 import type { BridgeConfig } from '../shared/types/config.js';
-export declare function bridgeBootstrap(url: URL, config: BridgeConfig | string, routeConfig?: RouteGuardConfig): Promise<void>;
-export declare const bridgeReady: import("svelte/store").Writable<boolean>;
-export declare function waitForBridge(): Promise<void>;
+export declare function bridgeBootstrap(url: URL, config: BridgeConfig | string, routeConfig?: RouteGuardConfig): Promise<{
+    flagsReady: Promise<void>;
+} | undefined>;
+export declare const bridgeReady: import("svelte/store").Readable<boolean>;
+export { _waitForBridge as waitForBridge };

package/dist/client/BridgeBootstrap.js

@@ -1,44 +1,34 @@
 // src/lib/bridge/bootstrap.ts
 import { isRedirect, redirect } from '@sveltejs/kit';
-import { get, writable } from 'svelte/store';
+import { get } from 'svelte/store';
 import { createRouteGuard } from '../auth/route-guard.js';
+import { getBridgeAuth, bridgeReadyStore, markReady, waitForBridge as _waitForBridge, } from '../core/bridge-instance.js';
 import { featureFlags } from '../shared/feature-flag.js';
 import { logger } from '../shared/logger.js';
-import { auth, maybeRefreshNow } from '../shared/services/auth.service.js';
-import { bridgeConfig } from './stores/config.store.js';
-const bridgeReadyStore = writable(false);
-let resolveReady = null;
-const bridgeReadyPromise = new Promise((resolve) => {
-    resolveReady = resolve;
-});
-function markBridgeReady() {
-    if (get(bridgeReadyStore))
-        return;
-    bridgeReadyStore.set(true);
-    resolveReady?.();
-}
+import { bridgeConfig, getConfig } from './stores/config.store.js';
 export async function bridgeBootstrap(url, config, routeConfig = { rules: [], defaultAccess: 'protected' }) {
     // If we've already completed bootstrap once, short-circuit
     if (get(bridgeReadyStore)) {
         return;
     }
     const finalConfig = typeof config === 'string' ? { appId: config } : config;
-    // 1. Initialize configuration (synchronously)
+    // 1. Initialize configuration (synchronously) — this also calls initBridge()
     bridgeConfig.initConfig(finalConfig, routeConfig);
     // 1a. If we're on bridge OAuth callback route, let bridge dedicated route handle it
     try {
-        const callbackPath = finalConfig.callbackUrl ? new URL(finalConfig.callbackUrl).pathname : null;
+        const resolvedCallbackUrl = getConfig().callbackUrl;
+        const callbackPath = resolvedCallbackUrl ? new URL(resolvedCallbackUrl).pathname : null;
         if (callbackPath && url.pathname === callbackPath) {
             logger.debug('[bridgeBootstrap] callback route detected, skipping bootstrap flow');
-            const { handleCallback } = auth;
+            const bridge = getBridgeAuth();
             const code = url.searchParams.get('code');
             logger.debug('[bridgeBootstrap] callback code check', { hasCode: !!code, pathname: url.pathname });
             if (code) {
                 try {
                     logger.debug('[bridgeBootstrap] calling handleCallback');
-                    await handleCallback(code);
+                    await bridge.handleCallback(code);
                     // Verify tokens before redirect
-                    const tokensAfterCallback = auth.getToken();
+                    const tokensAfterCallback = bridge.getTokens();
                     const isAuthAfterCallback = !!tokensAfterCallback?.accessToken;
                     logger.debug('[bridgeBootstrap] after handleCallback', {
                         hasTokens: !!tokensAfterCallback?.accessToken,
@@ -70,13 +60,26 @@ export async function bridgeBootstrap(url, config, routeConfig = { rules: [], de
         logger.warn('[bridgeBootstrap] failed parsing callbackUrl', e);
     }
     // 2. Ensure tokens are fresh if needed
-    await maybeRefreshNow();
-    // 3. Load feature flags before guard if your guard depends on bridgem
-    await featureFlags.refresh();
+    try {
+        const bridge = getBridgeAuth();
+        if (bridge.isAuthenticated()) {
+            await bridge.refreshTokens();
+        }
+    }
+    catch {
+        // Non-fatal — stale tokens will be caught by route guard
+    }
+    // 3. Fire flag fetch without awaiting so GQL queries can start in parallel.
+    //    The flagsReady promise is passed to the guard and returned to callers
+    //    so routes that need flags can still await before rendering.
+    //    Swallow errors — feature flag failures should never crash the bootstrap.
+    const flagsReady = featureFlags.refresh().catch((err) => {
+        logger.warn('[bridgeBootstrap] Feature flags failed to load:', err);
+    });
     // 4. Handle route guarding and redirects
-    const guard = createRouteGuard();
-    // Check auth state before route guard decision
-    const currentTokens = auth.getToken();
+    const guard = createRouteGuard(flagsReady);
+    const bridge = getBridgeAuth();
+    const currentTokens = bridge.getTokens();
     const currentAuth = !!currentTokens?.accessToken;
     logger.debug('[bridgeBootstrap] before route guard check', {
         pathname: url.pathname,
@@ -86,15 +89,17 @@ export async function bridgeBootstrap(url, config, routeConfig = { rules: [], de
     const decision = await guard.getNavigationDecision(url.pathname);
     logger.debug('[bridgeBootstrap] navigation decision', decision);
     if (decision.type === 'login') {
-        redirect(303, auth.createLoginUrl());
+        const { loginRoute } = getConfig();
+        // SDK mode: consumer explicitly set loginRoute → redirect to in-app login view
+        // Hosted mode (default): no loginRoute → redirect to hosted auth portal
+        redirect(303, loginRoute ?? bridge.createLoginUrl());
     }
     if (decision.type === 'redirect' && url.pathname !== decision.to) {
         redirect(303, decision.to);
     }
     logger.debug('[bridgeBootstrap] in bridge end');
-    markBridgeReady();
+    markReady();
+    return { flagsReady };
 }
 export const bridgeReady = bridgeReadyStore;
-export function waitForBridge() {
-    return bridgeReadyPromise;
-}
+export { _waitForBridge as waitForBridge };

package/dist/client/BridgeBootstrap.svelte

@@ -1,23 +1,27 @@
-<script lang="ts">  
-  import { beforeNavigate } from '$app/navigation';
+<script lang="ts">
+  import { beforeNavigate, goto } from '$app/navigation';
   import { onMount } from 'svelte';
   import { createRouteGuard } from '../auth/route-guard.js';
-  import { auth, startAutoRefresh } from '../shared/services/auth.service.js';
+  import { getBridgeAuth } from '../core/bridge-instance.js';
+  import { getConfig } from './stores/config.store.js';
 
   // Props: require config to be passed by consumer, now including onBootstrapComplete
   let {onBootstrapComplete }: {
-   
     onBootstrapComplete?: () => void
   } = $props();
 
-  const { login } = auth;
   const guard = createRouteGuard();
 
   async function handleRoute(pathname: string, cancel?: () => void) {
-    const decision = await guard.getNavigationDecision(pathname);    
+    const decision = await guard.getNavigationDecision(pathname);
     if (decision.type === 'login') {
       if (cancel) cancel();
-      login();
+      const { loginRoute } = getConfig();
+      if (loginRoute) {
+        goto(loginRoute);
+      } else {
+        getBridgeAuth().login();
+      }
       return;
     }
     if (decision.type === 'redirect' && window.location.pathname !== decision.to) {
@@ -27,10 +31,8 @@
     }
   }
 
-  onMount(async () => {        
-      startAutoRefresh();
-    
-    // Signal completion
+  onMount(async () => {
+    // Auth-core manages auto-refresh internally — no startAutoRefresh() needed
     if (onBootstrapComplete) onBootstrapComplete();
   });
 
@@ -38,4 +40,4 @@
     if (!to) return;
     await handleRoute(to.url.pathname, cancel);
   });
-</script>
+</script>

package/dist/client/components/ProfileName.svelte

@@ -0,0 +1,18 @@
+<script lang="ts">
+  import type { HTMLAttributes } from 'svelte/elements';
+  import { profileStore } from '../../shared/profile.js';
+
+  interface Props extends HTMLAttributes<HTMLSpanElement> {}
+
+  let { class: className, style, ...rest }: Props = $props();
+
+  const { profile } = profileStore;
+
+  let displayName = $derived(
+    $profile?.fullName || $profile?.email || ''
+  );
+</script>
+
+{#if displayName}
+  <span class={className} {style} data-bridge-profile-name {...rest}>{displayName}</span>
+{/if}

package/dist/client/components/ProfileName.svelte.d.ts

@@ -0,0 +1,6 @@
+import type { HTMLAttributes } from 'svelte/elements';
+interface Props extends HTMLAttributes<HTMLSpanElement> {
+}
+declare const ProfileName: import("svelte").Component<Props, {}, "">;
+type ProfileName = ReturnType<typeof ProfileName>;
+export default ProfileName;