@equinor/fusion-framework-app 13.0.0 → 14.0.0-next.0

package/dist/esm/mock/AppMockConfigurator.js

@@ -0,0 +1,183 @@
+import http from '@equinor/fusion-framework-module-http';
+import { msalMockModule, } from '@equinor/fusion-framework-module-msal/mock';
+import { AppConfigurator } from '../AppConfigurator.js';
+/**
+ * The real `AppConfigurator`, with the `msal` module it registers backed by
+ * the same test double `FrameworkMockConfigurator` uses. `http` is the real
+ * module — fake a response by registering a short-circuiting middleware
+ * through `.http.addMiddleware(...)` instead of swapping the module out.
+ *
+ * @remarks
+ * Nothing else changes: the same module set (`event`, `http`, `msal`), the same
+ * configuration pipeline and the same lifecycle are used. `configureHttpClient`,
+ * `useFrameworkServiceClient` and any callback written for a real
+ * `AppConfigurator` work against this unchanged.
+ *
+ * `http` and `msal` are pinned early — mirroring `FrameworkMockConfigurator`,
+ * one level down — so `.http` and `.msal` are reachable synchronously, before
+ * `useFrameworkServiceClient` or a `configureModules` callback ever runs.
+ * `event` is deliberately not pinned, for the same reason it isn't in
+ * `FrameworkMockConfigurator`: its `configure` factory reads `ref` to wire
+ * bubbling to a parent event provider, and pinning would freeze that decision
+ * before a `ref` could ever be known.
+ *
+ * @typeParam TModules - Module descriptors beyond the default set. Supply this
+ *   when a test registers application modules, so they are typed on the result.
+ * @typeParam TRef - The resolved Fusion modules instance used as a reference during initialization.
+ * @typeParam TEnv - The application environment descriptor.
+ *
+ * @example
+ * ```typescript
+ * const manifest = { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const;
+ * const configurator = new AppMockConfigurator({ manifest });
+ *
+ * configurator.configureHttpClient('catalog', { baseUri: 'https://api.example.com' });
+ * configurator.http.addMiddleware(async (uri, init, next) =>
+ *   uri === 'https://api.example.com/items' ? Response.json([{ id: 1 }]) : next(uri, init),
+ * );
+ * ```
+ */
+export class AppMockConfigurator extends AppConfigurator {
+    static className = 'AppMockConfigurator';
+    // Keyed by module name, so `_getConfig` can look a pinned configurator up
+    // without needing the module descriptor again.
+    #configurators = new Map();
+    // Keyed by module name, so `addConfig` can redirect a registration at the
+    // pinned descriptor instead of the unpinned one it was given.
+    #pinnedModules = new Map();
+    /**
+     * Creates an app configurator backed by the built-in mock modules.
+     *
+     * @param env - The application environment containing manifest, config, and optional basename.
+     */
+    constructor(env) {
+        super(env);
+        // Pinning up front replaces the modules AppConfigurator's own constructor
+        // already registered, whether or not a test ever touches the accessor.
+        this._pin(http);
+        this._pin(msalMockModule);
+        // deferred from AppConfigurator's own constructor (see the override below) until
+        // after pinning, so endpoint-derived clients register against the pinned http module
+        super._configureHttpClientsFromAppConfig();
+    }
+    /**
+     * No-ops the base constructor's own call to this, since it would otherwise run
+     * before {@link _pin} has anything to redirect `addConfig` at; this class calls
+     * {@link AppConfigurator._configureHttpClientsFromAppConfig} itself once pinned.
+     */
+    _configureHttpClientsFromAppConfig() { }
+    /**
+     * Registers a module configurator, redirecting registrations for a pinned module
+     * at its pinned descriptor.
+     *
+     * @remarks
+     * `configureHttpClient`, `useFrameworkServiceClient` and similar helpers always
+     * pass the real, unpinned module descriptor — the base `addConfig` replaces a
+     * module's descriptor whenever it doesn't recognize the object it's given, even
+     * under the same name, which would otherwise silently un-pin it.
+     *
+     * @param config - The module configurator descriptor to register.
+     * @template T - The module type being configured.
+     * @template TConfig - The resolved configuration type for the module.
+     */
+    addConfig(config) {
+        const pinnedModule = this.#pinnedModules.get(config.module.name);
+        super.addConfig(pinnedModule ? { ...config, module: pinnedModule } : config);
+    }
+    /**
+     * Pins a module to a single configurator instance for the lifetime of this
+     * configurator, so it can be reached by name through {@link _getConfig}.
+     *
+     * @remarks
+     * The module system otherwise builds a fresh configurator from its own
+     * `configure` factory during the configure phase — too late for a test to
+     * reach, and a new instance on every call besides. This replaces that factory
+     * with one that always returns the same instance, and registers the result
+     * under the module's own name.
+     *
+     * An application module supplied through {@link TModules} uses this the same
+     * way `.http` and `.msal` do, to expose its own named accessor:
+     *
+     * ```typescript
+     * class MyAppMockConfigurator extends AppMockConfigurator<[WidgetsModule]> {
+     *   constructor(env: AppEnv) {
+     *     super(env);
+     *     this._pin(widgetsMockModule);
+     *   }
+     *
+     *   public get widgets(): WidgetsMockConfigurator {
+     *     return this._getConfig('widgets');
+     *   }
+     * }
+     * ```
+     *
+     * @param module - The module descriptor to pin a configurator for.
+     * @template TModule - The specific module descriptor type being pinned.
+     * @throws {Error} If the module declares no `configure` factory to pin, or
+     *   the factory returns a promise instead of a configurator — pinning is
+     *   synchronous, so a test can reach the accessor immediately.
+     */
+    _pin(module) {
+        // A module without a configure factory has nothing this method could pin
+        if (!module.configure) {
+            throw new Error(`Cannot pin "${module.name}": it declares no configure factory.`);
+        }
+        const instance = module.configure();
+        // Async factories would make the pinned instance unavailable until the module system
+        // resolves it later, defeating the point of pinning it for immediate synchronous access
+        if (instance instanceof Promise) {
+            throw new Error(`Cannot pin "${module.name}": its configure factory returns a promise, so it cannot be resolved synchronously.`);
+        }
+        this.#configurators.set(module.name, instance);
+        const pinnedModule = { ...module, configure: () => instance };
+        this.#pinnedModules.set(module.name, pinnedModule);
+        this.addConfig({ module: pinnedModule });
+    }
+    /**
+     * Returns the configurator pinned for a module by name.
+     *
+     * @param name - The module's name, as passed to {@link _pin}.
+     * @template TConfig - The specific configurator type expected for this module.
+     * @returns The configurator pinned under `name`.
+     * @throws {Error} If no configurator has been pinned for that name.
+     */
+    _getConfig(name) {
+        const config = this.#configurators.get(name);
+        // A missing entry means _pin was never called for this module name
+        if (config === undefined) {
+            throw new Error(`No configurator is pinned for module "${name}" — call this._pin(module) before this._getConfig("${name}").`);
+        }
+        return config;
+    }
+    /**
+     * Configures the app's named HTTP clients.
+     *
+     * @remarks
+     * The same {@link IHttpClientConfigurator} the `http` module is configured
+     * from — the real one, not a test double. Every client it builds —
+     * including ones registered through
+     * {@link AppConfigurator.configureHttpClient} or
+     * {@link AppConfigurator.useFrameworkServiceClient} — is reachable here to
+     * register a short-circuiting {@link HttpMiddleware} through
+     * `addMiddleware`, so it answers from that instead of the network.
+     *
+     * @returns The real HTTP configurator.
+     */
+    get http() {
+        return this._getConfig(http.name);
+    }
+    /**
+     * Configures the user the app's `msal` module signs in.
+     *
+     * @remarks
+     * The same {@link MsalMockConfigurator} the `msal` module is configured from,
+     * so a change made here is what the module sees.
+     *
+     * @returns The MSAL mock configurator.
+     */
+    get msal() {
+        return this._getConfig(msalMockModule.name);
+    }
+}
+export default AppMockConfigurator;
+//# sourceMappingURL=AppMockConfigurator.js.map

package/dist/esm/mock/AppMockConfigurator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AppMockConfigurator.js","sourceRoot":"","sources":["../../../src/mock/AppMockConfigurator.ts"],"names":[],"mappings":"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"}

package/dist/esm/mock/enable-app-manifest-mock.js

@@ -0,0 +1,49 @@
+import { AppConfig, enableAppModule } from '@equinor/fusion-framework-module-app';
+import { MockAppClient } from '@equinor/fusion-framework-module-app/mock';
+/**
+ * Enables the `app` module on a parent framework configurator, wrapping its
+ * client in a {@link MockAppClient} so this app's manifest and config resolve
+ * locally.
+ *
+ * @remarks
+ * The underlying http client is still resolved the same way `AppConfigurator`
+ * resolves it (a pre-configured client, falling back to service discovery), so
+ * a caller pointing `serviceDiscovery` at something else — e.g. a real local
+ * mock server — is honored for every request `MockAppClient` doesn't answer
+ * itself. {@link mockAppModules} uses this to wire its zero-config default
+ * parent; call it directly when building a custom parent (via
+ * {@link mockFramework}) that also needs this app's own manifest servable.
+ *
+ * @param configurator - The parent framework's mock configurator, with `app` in its module set.
+ * @param env - The application environment whose manifest (and optional config) should be served.
+ * @param assetUri - Overrides the base URI a loaded app's script is imported from.
+ * @template TEnv - The application environment descriptor.
+ *
+ * @example Custom service discovery, same manifest resolution
+ * ```typescript
+ * const fusion = await mockFramework<[AppModule]>((configurator) => {
+ *   configurator.serviceDiscovery.setBaseUri('http://localhost:9999');
+ *   enableAppManifestMock(configurator, env);
+ * });
+ * const modules = await mockAppModules(undefined, env, fusion);
+ * ```
+ */
+export function enableAppManifestMock(configurator, env, assetUri) {
+    enableAppModule(configurator, (builder) => {
+        // only override the default asset base when the caller supplies one; an
+        // explicit empty string is meaningful (selects a root-relative script path)
+        if (assetUri !== undefined) {
+            builder.setAssetUri(assetUri);
+        }
+        builder.setClient(async ({ requireInstance }) => {
+            const http = await requireInstance('http');
+            const client = http.hasClient('apps')
+                ? http.createClient('apps')
+                : await (await requireInstance('serviceDiscovery')).createClient('apps');
+            // fall back to a trivial config so `App.initialize()` can resolve without a caller-supplied one
+            return new MockAppClient(client, env.manifest, env.config ?? new AppConfig({ environment: {} }));
+        });
+    });
+}
+export default enableAppManifestMock;
+//# sourceMappingURL=enable-app-manifest-mock.js.map

package/dist/esm/mock/enable-app-manifest-mock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enable-app-manifest-mock.js","sourceRoot":"","sources":["../../../src/mock/enable-app-manifest-mock.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,eAAe,EAAkB,MAAM,sCAAsC,CAAC;AAClG,OAAO,EAAE,aAAa,EAAE,MAAM,2CAA2C,CAAC;AAK1E;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,qBAAqB,CACnC,YAAoD,EACpD,GAAS,EACT,QAAiB;IAEjB,eAAe,CAAC,YAAY,EAAE,CAAC,OAAO,EAAE,EAAE;QACxC,wEAAwE;QACxE,4EAA4E;QAC5E,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,OAAO,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QAChC,CAAC;QACD,OAAO,CAAC,SAAS,CAAC,KAAK,EAAE,EAAE,eAAe,EAAE,EAAE,EAAE;YAC9C,MAAM,IAAI,GAAG,MAAM,eAAe,CAAC,MAAM,CAAC,CAAC;YAC3C,MAAM,MAAM,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC;gBACnC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC;gBAC3B,CAAC,CAAC,MAAM,CAAC,MAAM,eAAe,CAAC,kBAAkB,CAAC,CAAC,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC;YAC3E,gGAAgG;YAChG,OAAO,IAAI,aAAa,CACtB,MAAM,EACN,GAAG,CAAC,QAAQ,EACZ,GAAG,CAAC,MAAM,IAAI,IAAI,SAAS,CAAoB,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CACpE,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC;AAED,eAAe,qBAAqB,CAAC"}

package/dist/esm/mock/index.js

@@ -0,0 +1,21 @@
+/**
+ * Zero-configuration application module pipelines for tests.
+ *
+ * @remarks
+ * Lets a test initialize an application's real module pipeline — real
+ * `event`/`http`/`msal` modules, real configuration pipeline, real lifecycle —
+ * while the boundaries that reach outside the process are substituted with the
+ * same deterministic fakes {@link https://www.npmjs.com/package/@equinor/fusion-framework | @equinor/fusion-framework}'s
+ * own `/mock` entry point uses. No credentials, no network access and no
+ * running parent portal are required.
+ *
+ * This entry point is test-runner agnostic: it contains no dependency on
+ * Vitest or any other test framework, so the same helpers work under any
+ * runner.
+ *
+ * @packageDocumentation
+ */
+export { mockAppModules } from './mock-app-modules.js';
+export { AppMockConfigurator } from './AppMockConfigurator.js';
+export { enableAppManifestMock } from './enable-app-manifest-mock.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/mock/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/mock/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,cAAc,EAA2B,MAAM,uBAAuB,CAAC;AAChF,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/esm/mock/mock-app-modules.js

@@ -0,0 +1,82 @@
+import { mockFramework } from '@equinor/fusion-framework/mock';
+import { initializeAppModules } from '../initialize-app-modules.js';
+import { AppMockConfigurator } from './AppMockConfigurator.js';
+import { enableAppManifestMock } from './enable-app-manifest-mock.js';
+/**
+ * Runs an application's module pipeline with no real credentials required,
+ * from either the parent framework or the app's own `http`/`msal`
+ * registrations.
+ *
+ * @remarks
+ * The real `AppConfigurator` pipeline is run — the real module set, the real
+ * configuration pipeline and the real lifecycle. Only the boundaries that
+ * would need credentials are substituted by default; the `http` module is
+ * the real `HttpClientConfigurator`, so a registered client only avoids the
+ * network for requests a middleware short-circuits with a response — a
+ * client with no matching middleware, or a middleware that calls `next`,
+ * still reaches the real network. A test exercises the wiring an
+ * application actually depends on rather than a reimplementation of it.
+ *
+ * The configurator passed to `cb` is an {@link AppMockConfigurator}, which *is*
+ * an `AppConfigurator`. `useFrameworkServiceClient`, `configureHttpClient` and
+ * any callback written for a real app work against it unchanged.
+ *
+ * `fusion` defaults to a fresh {@link mockFramework} instance with a real `app`
+ * module already enabled and this app's own manifest served at whatever URI
+ * service discovery resolves `'apps'` to, so a test needs no parent Fusion
+ * instance of its own — but an already-mocked (or real) instance can be passed
+ * to compose with other framework-level setup. To point the parent's service
+ * discovery at something else (e.g. a real local mock server) while keeping
+ * the manifest served consistently, build that `fusion` with
+ * {@link mockFramework} and call {@link enableAppManifestMock} yourself,
+ * after customizing `serviceDiscovery`.
+ *
+ * @template TModules - Module descriptors beyond the default set. Supply this
+ *   when a test registers application modules, so they are typed on the result.
+ * @template TEnv - The application environment descriptor.
+ * @param cb - Configuration callback invoked before module initialization, or `undefined` to skip it.
+ * @param env - The application environment (manifest, config, basename).
+ * @param fusion - The parent Fusion instance; defaults to a fresh {@link mockFramework} instance.
+ * @returns The initialized application module instance.
+ *
+ * @example Zero configuration
+ * ```typescript
+ * const manifest = { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const;
+ * const modules = await mockAppModules(undefined, { manifest });
+ * ```
+ *
+ * @example Register a client answered by the app's own mocked HTTP module
+ * ```typescript
+ * const manifest = { appKey: 'my-app', displayName: 'My App', description: 'My app', type: 'standalone' } as const;
+ * const modules = await mockAppModules(
+ *   (configurator) => {
+ *     configurator.useFrameworkServiceClient('portal-api');
+ *     configurator.http.addMiddleware(async (uri, init, next) =>
+ *       uri === 'https://portal-api.fusion.test/items' ? Response.json([{ id: 1 }]) : next(uri, init),
+ *     );
+ *   },
+ *   { manifest },
+ * );
+ *
+ * const items = await modules.http.createClient('portal-api').json('/items');
+ * ```
+ */
+export async function mockAppModules(cb, env, fusion) {
+    // `await` is illegal in a parameter default, so an omitted fusion is resolved here instead.
+    // The default parent also carries a real `app` module, serving this app's own manifest at
+    // whatever URI service discovery is currently configured to resolve `'apps'` to, so a test
+    // exercises the same portal wiring a real parent framework would provide.
+    const resolvedFusion = fusion ??
+        (await mockFramework((configurator) => enableAppManifestMock(configurator, env)));
+    const configurator = new AppMockConfigurator(env);
+    // Cast is safe: `initializeAppModules` returns the exact module instance produced by
+    // `configurator`, which was constructed with this same `TModules`. TypeScript widens
+    // `TModules` to its constraint (`AnyModule[]`) when inferring through the generic
+    // `TConfigurator` parameter, so the assignment needs an explicit assertion here.
+    return initializeAppModules(configurator, cb, {
+        fusion: resolvedFusion,
+        env,
+    });
+}
+export default mockAppModules;
+//# sourceMappingURL=mock-app-modules.js.map

package/dist/esm/mock/mock-app-modules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mock-app-modules.js","sourceRoot":"","sources":["../../../src/mock/mock-app-modules.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAK/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAGpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAatE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAIlC,EAAkD,EAClD,GAAS,EACT,MAAe;IAEf,4FAA4F;IAC5F,0FAA0F;IAC1F,2FAA2F;IAC3F,0EAA0E;IAC1E,MAAM,cAAc,GAClB,MAAM;QACN,CAAC,MAAM,aAAa,CAAc,CAAC,YAAY,EAAE,EAAE,CAAC,qBAAqB,CAAC,YAAY,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IACjG,MAAM,YAAY,GAAG,IAAI,mBAAmB,CAAoC,GAAG,CAAC,CAAC;IACrF,qFAAqF;IACrF,qFAAqF;IACrF,kFAAkF;IAClF,iFAAiF;IACjF,OAAO,oBAAoB,CAAC,YAAY,EAAE,EAAE,EAAE;QAC5C,MAAM,EAAE,cAAc;QACtB,GAAG;KACJ,CAA0C,CAAC;AAC9C,CAAC;AAED,eAAe,cAAc,CAAC"}

package/dist/esm/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = '13.0.0';
+export const version = '14.0.0-next.0';
 //# sourceMappingURL=version.js.map

package/dist/esm/version.js.map

@@ -1 +1 @@
-{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,MAAM,CAAC,MAAM,OAAO,GAAG,QAAQ,CAAC"}
+{"version":3,"file":"version.js","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,MAAM,CAAC,MAAM,OAAO,GAAG,eAAe,CAAC"}