@equinor/fusion-framework-module-app 2.1.6 → 2.2.0

package/dist/types/AppModuleProvider.d.ts

@@ -0,0 +1,26 @@
+import { Observable } from 'rxjs';
+import { ModuleType } from '@equinor/fusion-framework-module';
+import { Query } from '@equinor/fusion-query';
+import { EventModule } from '@equinor/fusion-framework-module-event';
+import type { AppConfig, AppManifest } from './types';
+import { App } from './app/App';
+import { AppModuleConfig } from './configurator';
+export declare class AppModuleProvider {
+    #private;
+    static compareAppManifest<T extends AppManifest>(a?: T, b?: T): boolean;
+    appClient: Query<AppManifest, {
+        appKey: string;
+    }>;
+    get current(): App | undefined;
+    get current$(): Observable<App>;
+    constructor(args: {
+        config: AppModuleConfig;
+        event?: ModuleType<EventModule>;
+    });
+    getAppManifest(appKey: string): Observable<AppManifest>;
+    getAllAppManifests(): Observable<AppManifest[]>;
+    getAppConfig<TType = unknown>(appKey: string, tag?: string): Observable<AppConfig<TType>>;
+    setCurrentApp(appKey: string): void;
+    dispose(): void;
+}
+export default AppModuleProvider;

package/dist/types/app/App.d.ts

@@ -0,0 +1,34 @@
+import { AppConfig, AppManifest, AppModulesInstance, AppScriptModule } from '../types';
+import { Observable } from '@equinor/fusion-observable';
+import type { AppModuleProvider } from '../AppModuleProvider';
+import { OperatorFunction } from 'rxjs';
+import { EventModule } from '@equinor/fusion-framework-module-event';
+import { AnyModule, ModuleType } from '@equinor/fusion-framework-module';
+import '../events';
+export declare function filterEmpty<T>(): OperatorFunction<T | null | undefined, T>;
+export declare class App<TEnv = any, TModules extends Array<AnyModule> | unknown = unknown> {
+    #private;
+    get manifest$(): Observable<AppManifest>;
+    get config$(): Observable<AppConfig<TEnv>>;
+    get modules$(): Observable<AppScriptModule>;
+    get instance$(): Observable<AppModulesInstance<TModules>>;
+    get appKey(): string;
+    get manifest(): Promise<AppManifest>;
+    get config(): Promise<AppConfig<TEnv>>;
+    get instance(): AppModulesInstance<TModules> | undefined;
+    constructor(appKey: string, args: {
+        provider: AppModuleProvider;
+        event?: ModuleType<EventModule>;
+    });
+    initialize(): Observable<[AppManifest, AppScriptModule, AppConfig]>;
+    loadConfig(): void;
+    loadManifest(): void;
+    loadAppModule(allow_cache?: boolean): Promise<void>;
+    getConfig(force_refresh?: boolean): Observable<AppConfig>;
+    getConfigAsync(allow_cache?: boolean): Promise<AppConfig>;
+    getManifest(force_refresh?: boolean): Observable<AppManifest>;
+    getManifestAsync(allow_cache?: boolean): Promise<AppManifest>;
+    getAppModule(force_refresh?: boolean): Observable<AppScriptModule>;
+    getAppModuleAsync(allow_cache?: boolean): Promise<AppScriptModule>;
+    dispose: VoidFunction;
+}

package/dist/types/app/actions.d.ts

@@ -0,0 +1,46 @@
+import { ActionInstanceMap, ActionTypes } from '@equinor/fusion-observable';
+import { AppConfig, AppManifest, AppModulesInstance, AppScriptModule } from '../types';
+declare const createActions: () => {
+    setManifest: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[manifest: AppManifest], AppManifest, "set_manifest", never, {
+        created: number;
+    }>;
+    fetchManifest: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[key: string], string, "fetch_manifest::request", never, never> & {
+        success: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[manifest: AppManifest], AppManifest, "fetch_manifest::success", never, never>;
+        failure: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "fetch_manifest::failure", never, never>;
+    };
+    setConfig: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[config: AppConfig<unknown>], AppConfig<unknown>, "set_config", never, never>;
+    fetchConfig: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[key: string], string, "fetch_config::request", never, never> & {
+        success: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[config: AppConfig<unknown>], AppConfig<unknown>, "fetch_config::success", never, never>;
+        failure: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "fetch_config::failure", never, never>;
+    };
+    setModule: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[module: any], any, "set_module", never, never>;
+    importApp: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[entrypoint: string], string, "import_app::request", never, never> & {
+        success: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[module: AppScriptModule], AppScriptModule, "import_app::success", never, never>;
+        failure: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "import_app::failure", never, never>;
+    };
+    setInstance: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[instance: AppModulesInstance<unknown>], AppModulesInstance<unknown>, "set_instance", never, never>;
+};
+export declare const actions: {
+    setManifest: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[manifest: AppManifest], AppManifest, "set_manifest", never, {
+        created: number;
+    }>;
+    fetchManifest: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[key: string], string, "fetch_manifest::request", never, never> & {
+        success: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[manifest: AppManifest], AppManifest, "fetch_manifest::success", never, never>;
+        failure: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "fetch_manifest::failure", never, never>;
+    };
+    setConfig: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[config: AppConfig<unknown>], AppConfig<unknown>, "set_config", never, never>;
+    fetchConfig: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[key: string], string, "fetch_config::request", never, never> & {
+        success: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[config: AppConfig<unknown>], AppConfig<unknown>, "fetch_config::success", never, never>;
+        failure: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "fetch_config::failure", never, never>;
+    };
+    setModule: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[module: any], any, "set_module", never, never>;
+    importApp: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[entrypoint: string], string, "import_app::request", never, never> & {
+        success: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[module: AppScriptModule], AppScriptModule, "import_app::success", never, never>;
+        failure: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "import_app::failure", never, never>;
+    };
+    setInstance: import("@equinor/fusion-observable/dist/types/create-action").ActionCreatorWithPreparedPayload<[instance: AppModulesInstance<unknown>], AppModulesInstance<unknown>, "set_instance", never, never>;
+};
+export type ActionBuilder = ReturnType<typeof createActions>;
+export type ActionMap = ActionInstanceMap<ActionBuilder>;
+export type Actions = ActionTypes<typeof actions>;
+export {};

package/dist/types/app/create-reducer.d.ts

@@ -0,0 +1,3 @@
+import { AppBundleState } from './types';
+export declare const createReducer: (appKey: string) => import("@equinor/fusion-observable").ReducerWithInitialState<AppBundleState<any, any>, import("@equinor/fusion-observable").AnyAction>;
+export default createReducer;

package/dist/types/app/create-state.d.ts

@@ -0,0 +1,5 @@
+import { FlowSubject } from '@equinor/fusion-observable';
+import type { Actions } from './actions';
+import type { AppBundleState } from './types';
+import type { AppModuleProvider } from '../AppModuleProvider';
+export declare const createState: (appKey: string, provider: AppModuleProvider) => FlowSubject<AppBundleState, Actions>;

package/dist/types/app/flows.d.ts

@@ -0,0 +1,7 @@
+import type { Flow } from '@equinor/fusion-observable';
+import type { AppModuleProvider } from '../AppModuleProvider';
+import type { Actions } from './actions';
+import { AppBundleState } from './types';
+export declare const handleFetchManifest: (provider: AppModuleProvider) => Flow<Actions, AppBundleState>;
+export declare const handleFetchConfig: (provider: AppModuleProvider) => Flow<Actions, AppBundleState>;
+export declare const handleImportApplication: () => Flow<Actions, AppBundleState>;

package/dist/types/app/types.d.ts

@@ -0,0 +1,9 @@
+import type { AppConfig, AppManifest, AppModulesInstance, AppScriptModule } from '../types';
+export type AppBundleState<TConfig = any, TModules = any> = {
+    appKey: string;
+    status: Set<string>;
+    manifest?: AppManifest;
+    config?: AppConfig<TConfig>;
+    modules?: AppScriptModule;
+    instance?: AppModulesInstance<TModules>;
+};

package/dist/types/configurator.d.ts

@@ -2,23 +2,23 @@ import { AnyModule, ModuleInitializerArgs } from '@equinor/fusion-framework-modu
 import { IHttpClient } from '@equinor/fusion-framework-module-http';
 import { QueryCtorOptions } from '@equinor/fusion-query';
 import type { AppConfig, AppManifest, ModuleDeps } from './types';
-export interface IAppModuleConfig {
-    getApp: QueryCtorOptions<AppManifest, {
+export interface AppModuleConfig {
+    getAppManifest: QueryCtorOptions<AppManifest, {
         appKey: string;
     }>;
-    getApps: QueryCtorOptions<AppManifest[], void>;
-    getConfig: QueryCtorOptions<AppConfig, {
+    getAppManifests: QueryCtorOptions<AppManifest[], void>;
+    getAppConfig: QueryCtorOptions<AppConfig, {
         appKey: string;
         tag?: string;
     }>;
 }
 export interface IAppConfigurator<TDeps extends Array<AnyModule>> {
-    createConfig: (args: ModuleInitializerArgs<IAppConfigurator<TDeps>, TDeps>) => Promise<IAppModuleConfig>;
-    processConfig: (config: IAppModuleConfig) => IAppModuleConfig;
+    createConfig: (args: ModuleInitializerArgs<IAppConfigurator<TDeps>, TDeps>) => Promise<AppModuleConfig>;
+    processConfig: (config: AppModuleConfig) => AppModuleConfig;
 }
 export declare class AppConfigurator<TDeps extends ModuleDeps = ModuleDeps> implements IAppConfigurator<TDeps> {
     defaultExpireTime: number;
     protected _createHttpClient(init: ModuleInitializerArgs<IAppConfigurator<TDeps>, TDeps>): Promise<IHttpClient>;
-    createConfig(args: ModuleInitializerArgs<IAppConfigurator<TDeps>, TDeps>): Promise<IAppModuleConfig>;
-    processConfig(config: IAppModuleConfig): IAppModuleConfig;
+    createConfig(args: ModuleInitializerArgs<IAppConfigurator<TDeps>, TDeps>): Promise<AppModuleConfig>;
+    processConfig(config: AppModuleConfig): AppModuleConfig;
 }

package/dist/types/errors.d.ts

@@ -0,0 +1,16 @@
+type AppErrorType = 'not_found' | 'unauthorized' | 'unknown';
+export declare class AppManifestError extends Error {
+    readonly type: AppErrorType;
+    static fromHttpResponse(response: Response, options?: ErrorOptions): AppManifestError;
+    constructor(type: AppErrorType, message?: string, options?: ErrorOptions);
+}
+export declare class AppConfigError extends Error {
+    readonly type: AppErrorType;
+    static fromHttpResponse(response: Response, options?: ErrorOptions): AppConfigError;
+    constructor(type: AppErrorType, message?: string, options?: ErrorOptions);
+}
+export declare class AppScriptModuleError extends Error {
+    readonly type: AppErrorType;
+    constructor(type: AppErrorType, message?: string, options?: ErrorOptions);
+}
+export {};

package/dist/types/events.d.ts

@@ -0,0 +1,22 @@
+import { AnyModule } from '@equinor/fusion-framework-module';
+import { FrameworkEvent, FrameworkEventInit } from '@equinor/fusion-framework-module-event';
+import { App } from 'app/App';
+import AppModuleProvider from 'AppModuleProvider';
+import { AppModulesInstance } from './types';
+type AppModulesLoadedEventInit<TModules extends Array<AnyModule> | unknown = unknown> = FrameworkEventInit<{
+    appKey: string;
+    modules: AppModulesInstance<TModules>;
+}>;
+export declare class AppModulesLoadedEvent<TModules extends Array<AnyModule> | unknown = unknown> extends FrameworkEvent<AppModulesLoadedEventInit<TModules>> {
+    constructor(appKey: string, modules: AppModulesInstance<TModules>, init?: Omit<AppModulesLoadedEventInit<TModules>, 'detail'>);
+}
+declare module '@equinor/fusion-framework-module-event' {
+    interface FrameworkEventMap {
+        onAppModulesLoaded: AppModulesLoadedEvent;
+        onCurrentAppChanged: FrameworkEvent<FrameworkEventInit<{
+            next?: App;
+            previous?: App;
+        }, AppModuleProvider>>;
+    }
+}
+export {};

package/dist/types/index.d.ts

@@ -1,4 +1,6 @@
-export { AppConfigurator, IAppConfigurator, IAppModuleConfig } from './configurator';
-export { AppProvider, IAppProvider } from './provider';
+export { AppConfigurator, IAppConfigurator, AppModuleConfig as IAppModuleConfig, } from './configurator';
+export { AppModuleProvider } from './AppModuleProvider';
+export { App } from './app/App';
+export * from './events';
 export * from './types';
 export { default, AppModule, module, moduleKey } from './module';

package/dist/types/module.d.ts

@@ -1,10 +1,11 @@
-import { Module } from '@equinor/fusion-framework-module';
+import { IModulesConfigurator, Module } from '@equinor/fusion-framework-module';
 import { ModuleDeps } from './types';
 import { IAppConfigurator } from './configurator';
-import { IAppProvider } from './provider';
+import { AppModuleProvider } from './AppModuleProvider';
 export declare const moduleKey = "app";
-export type AppModule = Module<typeof moduleKey, IAppProvider, IAppConfigurator<ModuleDeps>, ModuleDeps>;
+export type AppModule = Module<typeof moduleKey, AppModuleProvider, IAppConfigurator<ModuleDeps>, ModuleDeps>;
 export declare const module: AppModule;
+export declare const enableAppModule: (configurator: IModulesConfigurator) => void;
 export default module;
 declare module '@equinor/fusion-framework-module' {
     interface Modules {

package/dist/types/types.d.ts

@@ -1,6 +1,15 @@
+import { AnyModule, CombinedModules, ModulesInstance } from '@equinor/fusion-framework-module';
 import type { EventModule } from '@equinor/fusion-framework-module-event';
 import type { HttpModule } from '@equinor/fusion-framework-module-http';
+import { MsalModule } from '@equinor/fusion-framework-module-msal';
 import type { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
+type Fusion = any;
+export type AppEnv<TConfig = unknown, TProps = unknown> = {
+    basename?: string;
+    manifest?: AppManifest;
+    config?: AppConfig<TConfig>;
+    props?: TProps;
+};
 export type ModuleDeps = [HttpModule, ServiceDiscoveryModule, EventModule];
 export type AppType = 'standalone' | 'report' | 'launcher';
 export type AppAuth = {
@@ -14,7 +23,7 @@ type AppCategory = {
     defaultIcon: string | null;
 };
 export type AppManifest = {
-    key: string;
+    appKey: string;
     name: string;
     shortName: string;
     version: string;
@@ -40,4 +49,23 @@ export type AppConfig<TEnvironment = unknown> = {
     environment: TEnvironment;
     endpoints: Record<string, string | Endpoint>;
 };
+export type AppBundle<TEnvironment = unknown, TModule = unknown> = {
+    manifest: AppManifest;
+    config: AppConfig<TEnvironment>;
+    module: TModule;
+};
+export type AppModules<TModules extends Array<AnyModule> | unknown = unknown> = CombinedModules<TModules, [
+    EventModule,
+    HttpModule,
+    MsalModule
+]>;
+export type ComponentRenderArgs<TFusion extends Fusion = Fusion, TEnv = AppEnv> = {
+    fusion: TFusion;
+    env: TEnv;
+};
+export type AppScriptModule = {
+    default: (el: HTMLElement, args: ComponentRenderArgs) => VoidFunction;
+    renderApp: (el: HTMLElement, args: ComponentRenderArgs) => VoidFunction;
+};
+export type AppModulesInstance<TModules extends Array<AnyModule> | unknown = unknown> = ModulesInstance<AppModules<TModules>>;
 export {};

package/package.json

@@ -1,12 +1,20 @@
 {
     "name": "@equinor/fusion-framework-module-app",
-    "version": "2.1.6",
+    "version": "2.2.0",
     "description": "",
     "main": "dist/esm/index.js",
     "exports": {
-        ".": "./dist/esm/index.js"
+        ".": "./dist/esm/index.js",
+        "./errors.js": "./dist/esm/errors.js"
     },
     "types": "dist/types/index.d.ts",
+    "typesVersions": {
+        "*": {
+            "errors.js": [
+                "dist/types/errors.d.ts"
+            ]
+        }
+    },
     "scripts": {
         "build": "tsc -b",
         "prepack": "yarn build"
@@ -23,15 +31,15 @@
         "directory": "packages/module-app"
     },
     "dependencies": {
-        "@equinor/fusion-query": "^1.1.1",
+        "@equinor/fusion-query": "^1.1.2",
         "rxjs": "^7.5.7"
     },
     "devDependencies": {
         "@equinor/fusion-framework-module": "^1.2.10",
         "@equinor/fusion-framework-module-event": "^1.2.0",
-        "@equinor/fusion-framework-module-http": "^2.2.0",
-        "@equinor/fusion-framework-module-service-discovery": "^4.0.6",
+        "@equinor/fusion-framework-module-http": "^2.2.1",
+        "@equinor/fusion-framework-module-service-discovery": "^4.0.7",
         "typescript": "^4.9.3"
     },
-    "gitHead": "7c03916da17e754a65ec93ea06f8e1bb3e2412ab"
+    "gitHead": "acfc1533fae1e5a95f8463cc2d6e3a2ad94c252e"
 }

package/src/AppModuleProvider.ts

@@ -0,0 +1,159 @@
+import {
+    BehaviorSubject,
+    catchError,
+    distinctUntilKeyChanged,
+    map,
+    Observable,
+    pairwise,
+    Subscription,
+    takeWhile,
+} from 'rxjs';
+
+import { ModuleType } from '@equinor/fusion-framework-module';
+
+import { Query } from '@equinor/fusion-query';
+
+import { EventModule } from '@equinor/fusion-framework-module-event';
+
+import type { AppConfig, AppManifest } from './types';
+
+import { App, filterEmpty } from './app/App';
+import { AppModuleConfig } from './configurator';
+import { HttpResponseError } from '@equinor/fusion-framework-module-http';
+import { AppConfigError, AppManifestError } from './errors';
+
+export class AppModuleProvider {
+    static compareAppManifest<T extends AppManifest>(a?: T, b?: T): boolean {
+        return JSON.stringify(a) === JSON.stringify(b);
+    }
+
+    public appClient: Query<AppManifest, { appKey: string }>;
+    #appsClient: Query<AppManifest[], void>;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    #configClient: Query<AppConfig<any>, { appKey: string; tag?: string }>;
+
+    #current$: BehaviorSubject<App | undefined>;
+
+    #subscription = new Subscription();
+
+    #event?: ModuleType<EventModule>;
+
+    /**
+     * fetch an application by key
+     * @param appKey - application key
+     */
+    get current(): App | undefined {
+        return this.#current$.value;
+    }
+
+    get current$(): Observable<App> {
+        return this.#current$.pipe(filterEmpty(), distinctUntilKeyChanged('appKey'));
+    }
+
+    constructor(args: { config: AppModuleConfig; event?: ModuleType<EventModule> }) {
+        const { event, config } = args;
+
+        this.#event = event;
+
+        this.#current$ = new BehaviorSubject<App | undefined>(undefined);
+
+        this.appClient = new Query(config.getAppManifest);
+        this.#appsClient = new Query(config.getAppManifests);
+        this.#configClient = new Query(config.getAppConfig);
+
+        this.#subscription.add(() => this.appClient.complete());
+        this.#subscription.add(() => this.#appsClient.complete());
+        this.#subscription.add(() => this.#configClient.complete());
+        this.#subscription.add(
+            this.current$
+                .pipe(
+                    pairwise(),
+                    takeWhile(() => !!event)
+                )
+                .subscribe(([previous, next]) => {
+                    event?.dispatchEvent('onCurrentAppChanged', {
+                        source: this,
+                        detail: { previous, next },
+                    });
+                })
+        );
+
+        this.#subscription.add(
+            this.#current$
+                .pipe(
+                    pairwise(),
+                    map(([previous]) => previous),
+                    filterEmpty()
+                )
+                .subscribe((app) => app.dispose())
+        );
+    }
+
+    /**
+     * fetch an application by key
+     * @param appKey - application key
+     */
+    public getAppManifest(appKey: string): Observable<AppManifest> {
+        return Query.extractQueryValue(
+            this.appClient.query({ appKey }).pipe(
+                catchError((err) => {
+                    /** extract cause, since error will be a `QueryError` */
+                    const { cause } = err;
+                    if (cause instanceof AppManifestError) {
+                        throw cause;
+                    }
+                    if (cause instanceof HttpResponseError) {
+                        throw AppManifestError.fromHttpResponse(cause.response, { cause });
+                    }
+                    throw new AppManifestError('unknown', 'failed to load manifest', { cause });
+                })
+            )
+        );
+    }
+
+    /**
+     * fetch all applications
+     */
+    public getAllAppManifests(): Observable<AppManifest[]> {
+        return Query.extractQueryValue(this.#appsClient.query());
+    }
+
+    /**
+     * fetch configuration for an application
+     * @param appKey - application key
+     */
+    public getAppConfig<TType = unknown>(
+        appKey: string,
+        tag?: string
+    ): Observable<AppConfig<TType>> {
+        return Query.extractQueryValue(
+            this.#configClient.query({ appKey, tag }).pipe(
+                catchError((err) => {
+                    /** extract cause, since error will be a `QueryError` */
+                    const { cause } = err;
+                    if (cause instanceof AppConfigError) {
+                        throw cause;
+                    }
+                    if (cause instanceof HttpResponseError) {
+                        throw AppConfigError.fromHttpResponse(cause.response, { cause });
+                    }
+                    throw new AppConfigError('unknown', 'failed to load config', { cause });
+                })
+            )
+        );
+    }
+
+    /**
+     * set the current application, will internally resolve manifest
+     * @param appKey - application key
+     */
+    public setCurrentApp(appKey: string): void {
+        this.#current$.next(new App(appKey, { provider: this, event: this.#event }));
+    }
+
+    public dispose() {
+        this.#subscription.unsubscribe();
+    }
+}
+
+export default AppModuleProvider;