@squide/firefly 13.3.0 → 14.0.0

package/src/FireflyRuntime.tsx

@@ -1,6 +1,7 @@
-import type { RegisterRouteOptions, RuntimeOptions } from "@squide/core";
+import type { RegisterRouteOptions, RuntimeMethodOptions, RuntimeOptions } from "@squide/core";
 import { MswPlugin, MswPluginName } from "@squide/msw";
-import { ReactRouterRuntime, type Route } from "@squide/react-router";
+import { type IReactRouterRuntime, ReactRouterRuntime, ReactRouterRuntimeScope, type Route } from "@squide/react-router";
+import type { Logger } from "@workleap/logging";
 import type { RequestHandler } from "msw";
 import { getAreModulesRegistered } from "./AppRouterReducer.ts";
 import { type AppRouterStore, createAppRouterStore } from "./AppRouterStore.ts";
@@ -9,9 +10,18 @@ export interface FireflyRuntimeOptions extends RuntimeOptions {
     useMsw?: boolean;
 }
 
-export class FireflyRuntime extends ReactRouterRuntime {
-    readonly #appRouterStore: AppRouterStore;
-    readonly #useMsw: boolean;
+export interface RegisterRequestHandlersOptions extends RuntimeMethodOptions {}
+
+export interface IFireflyRuntime extends IReactRouterRuntime {
+    registerRequestHandlers: (handlers: RequestHandler[]) => void;
+    get requestHandlers(): RequestHandler[];
+    get appRouterStore(): AppRouterStore;
+    get isMswEnabled(): boolean;
+}
+
+export class FireflyRuntime extends ReactRouterRuntime implements IFireflyRuntime {
+    protected _appRouterStore: AppRouterStore;
+    protected _useMsw: boolean;
 
     constructor({ plugins, useMsw, ...options }: FireflyRuntimeOptions = {}) {
         if (useMsw) {
@@ -23,20 +33,21 @@ export class FireflyRuntime extends ReactRouterRuntime {
                 ...options
             });
 
-            this.#useMsw = true;
+            this._useMsw = true;
         } else {
             super({
                 plugins,
                 ...options
             });
 
-            this.#useMsw = false;
+            this._useMsw = false;
         }
 
-        this.#appRouterStore = createAppRouterStore(this._logger);
+        this._appRouterStore = createAppRouterStore(this._logger);
     }
 
-    registerRequestHandlers(handlers: RequestHandler[]) {
+    registerRequestHandlers(handlers: RequestHandler[], options: RegisterRequestHandlersOptions = {}) {
+        const logger = this._getLogger(options);
         const mswPlugin = this.getPlugin(MswPluginName) as MswPlugin;
 
         if (!mswPlugin) {
@@ -47,7 +58,9 @@ export class FireflyRuntime extends ReactRouterRuntime {
             throw new Error("[squide] Cannot register an MSW request handlers once the modules are registered. Are you trying to register an MSW request handler in a deferred registration function? Only navigation items can be registered in a deferred registration function.");
         }
 
-        mswPlugin.registerRequestHandlers(handlers);
+        mswPlugin.registerRequestHandlers(handlers, {
+            logger
+        });
     }
 
     // Must define a return type otherwise we get an "error TS2742: The inferred type of 'requestHandlers' cannot be named" error.
@@ -70,10 +83,35 @@ export class FireflyRuntime extends ReactRouterRuntime {
     }
 
     get appRouterStore() {
-        return this.#appRouterStore;
+        return this._appRouterStore;
+    }
+
+    get isMswEnabled() {
+        return this._useMsw;
+    }
+
+    startScope(logger: Logger): FireflyRuntime {
+        return (new FireflyRuntimeScope(this, logger) as unknown) as FireflyRuntime;
+    }
+}
+
+export class FireflyRuntimeScope<TRuntime extends FireflyRuntime = FireflyRuntime> extends ReactRouterRuntimeScope<TRuntime> implements IFireflyRuntime {
+    registerRequestHandlers(handlers: RequestHandler[], options: RegisterRequestHandlersOptions = {}) {
+        this._runtime.registerRequestHandlers(handlers, {
+            ...options,
+            logger: this._getLogger(options)
+        });
+    }
+
+    get requestHandlers(): RequestHandler[] {
+        return this._runtime.requestHandlers;
+    }
+
+    get appRouterStore() {
+        return this._runtime.appRouterStore;
     }
 
     get isMswEnabled() {
-        return this.#useMsw;
+        return this._runtime.isMswEnabled;
     }
 }

package/src/honeycomb/activeSpan.ts

@@ -1,6 +1,6 @@
 import type { Span } from "@opentelemetry/api";
 import { isPlainObject } from "@squide/core";
-import type { RootLogger } from "@workleap/logging";
+import type { Logger } from "@workleap/logging";
 import { v4 as uuidv4 } from "uuid";
 import { createTraceContextId } from "./createTraceContextId.ts";
 
@@ -97,7 +97,7 @@ export function popActiveSpan(span: ActiveSpan) {
     }
 }
 
-export function createOverrideFetchRequestSpanWithActiveSpanContext(logger: RootLogger) {
+export function createOverrideFetchRequestSpanWithActiveSpanContext(logger: Logger) {
     return (span: Span, request: Request | RequestInit) => {
         const activeSpan = getActiveSpan();
 

package/src/honeycomb/registerHoneycombInstrumentation.ts

@@ -37,7 +37,7 @@ import {
     RemoteModulesRegistrationStartedEvent,
     type RemoteModulesRegistrationStartedEventPayload
 } from "@squide/module-federation";
-import { ApplicationBoostrappedEvent, ModulesReadyEvent, ModulesRegisteredEvent, MswReadyEvent, ProtectedDataReadyEvent, PublicDataReadyEvent } from "../AppRouterReducer.ts";
+import { ApplicationBoostrappedEvent, type AppRouterWaitState, ModulesReadyEvent, ModulesRegisteredEvent, MswReadyEvent, ProtectedDataReadyEvent, PublicDataReadyEvent } from "../AppRouterReducer.ts";
 import type { FireflyRuntime } from "../FireflyRuntime.tsx";
 import { ApplicationBootstrappingStartedEvent } from "../initializeFirefly.ts";
 import { ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent } from "../useProtectedDataQueries.ts";
@@ -72,11 +72,16 @@ export function reduceDataFetchEvents(
         onPublicDataFetchStarted();
     }, { once: true });
 
-    runtime.eventBus.addListener(PublicDataReadyEvent, () => {
+    runtime.eventBus.addListener(PublicDataReadyEvent, payload => {
         onPublicDataReady();
 
         if (dataFetchState === "fetching-data") {
-            dataFetchState = "public-data-ready";
+            if (payload && !(payload as AppRouterWaitState).waitForProtectedData) {
+                dataFetchState = "data-ready";
+                onDataReady();
+            } else {
+                dataFetchState = "public-data-ready";
+            }
         } else if (dataFetchState === "protected-data-ready") {
             dataFetchState = "data-ready";
             onDataReady();
@@ -92,11 +97,16 @@ export function reduceDataFetchEvents(
         onProtectedDataFetchStarted();
     }, { once: true });
 
-    runtime.eventBus.addListener(ProtectedDataReadyEvent, () => {
+    runtime.eventBus.addListener(ProtectedDataReadyEvent, payload => {
         onProtectedDataReady();
 
         if (dataFetchState === "fetching-data") {
-            dataFetchState = "protected-data-ready";
+            if (payload && !(payload as AppRouterWaitState).waitForPublicData) {
+                dataFetchState = "data-ready";
+                onDataReady();
+            } else {
+                dataFetchState = "protected-data-ready";
+            }
         } else if (dataFetchState === "public-data-ready") {
             dataFetchState = "data-ready";
             onDataReady();
@@ -330,7 +340,13 @@ function registerTrackingListeners(runtime: FireflyRuntime) {
                 traceError(dataFetchSpan.instance, x);
             });
 
-            dataFetchSpan.instance.end();
+            endActiveSpan(dataFetchSpan);
+
+            // Global data fetch errors are unmanaged, which mean the host application bootstrapping flow
+            // will be aborted and a react-router error boundary will be rendered.
+            if (bootstrappingSpan) {
+                bootstrappingSpan.end();
+            }
         }
     };