@equinor/fusion-framework-module-app 0.0.0-next-20230915111233

package/src/app/create-state.ts

@@ -0,0 +1,21 @@
+import { FlowSubject } from '@equinor/fusion-observable';
+
+import { createReducer } from './create-reducer';
+
+import { handleFetchManifest, handleFetchConfig, handleImportApplication } from './flows';
+
+import type { Actions } from './actions';
+import type { AppBundleState, AppBundleStateInitial } from './types';
+import type { AppModuleProvider } from '../AppModuleProvider';
+
+export const createState = (
+    value: AppBundleStateInitial,
+    provider: AppModuleProvider,
+): FlowSubject<AppBundleState, Actions> => {
+    const reducer = createReducer(value);
+    const state = new FlowSubject<AppBundleState, Actions>(reducer);
+    state.addFlow(handleFetchManifest(provider));
+    state.addFlow(handleFetchConfig(provider));
+    state.addFlow(handleImportApplication());
+    return state;
+};

package/src/app/events.ts

@@ -0,0 +1,67 @@
+import type { FrameworkEvent, FrameworkEventInit } from '@equinor/fusion-framework-module-event';
+
+import type { App } from './App';
+
+import type { AppConfig, AppManifest, AppModulesInstance } from '../types';
+
+/** base event type for applications */
+export type AppEventEventInit<TDetail extends Record<string, unknown> | unknown = unknown> =
+    FrameworkEventInit<
+        /** additional event details and key of target event */
+        TDetail & { appKey: string },
+        /** source of the event */
+        App
+    >;
+
+declare module '@equinor/fusion-framework-module-event' {
+    interface FrameworkEventMap {
+        /** fired when the application has initiated its modules */
+        onAppModulesLoaded: FrameworkEvent<
+            AppEventEventInit<{
+                /** initiated modules for application */
+                modules: AppModulesInstance;
+            }>
+        >;
+
+        /** fired when the application has loaded corresponding manifest */
+        onAppManifestLoaded: FrameworkEvent<
+            AppEventEventInit<{
+                manifest: AppManifest;
+            }>
+        >;
+
+        /** fired when the application has loaded corresponding config */
+        onAppConfigLoaded: FrameworkEvent<
+            AppEventEventInit<{
+                config: AppConfig;
+            }>
+        >;
+
+        /** fired when the application has loaded corresponding javascript module */
+        onAppScriptLoaded: FrameworkEvent<
+            AppEventEventInit<{
+                manifest: AppManifest;
+            }>
+        >;
+
+        /** fired before application loads manifest, config and script */
+        onAppInitialize: FrameworkEvent<AppEventEventInit>;
+
+        /**
+         * fired after application has loaded manifest, config and script
+         *
+         * __note:__ not fired until all loaders has settled (last emit)
+         */
+        onAppInitialized: FrameworkEvent<AppEventEventInit>;
+
+        /** fired when application fails to load either manifest, config and script */
+        onAppInitializeFailed: FrameworkEvent<
+            AppEventEventInit<{
+                error: unknown;
+            }>
+        >;
+
+        /** fired when the application is disposed (unmounts) */
+        onAppDispose: FrameworkEvent<AppEventEventInit>;
+    }
+}

package/src/app/flows.ts

@@ -0,0 +1,61 @@
+import { from, of, merge } from 'rxjs';
+import { catchError, filter, last, map, switchMap } from 'rxjs/operators';
+
+import { actions } from './actions';
+
+import type { Flow } from '@equinor/fusion-observable';
+import type { AppModuleProvider } from '../AppModuleProvider';
+import type { Actions } from './actions';
+import type { AppBundleState } from './types';
+
+export const handleFetchManifest =
+    (provider: AppModuleProvider): Flow<Actions, AppBundleState> =>
+    (action$) =>
+        action$.pipe(
+            filter(actions.fetchManifest.match),
+            switchMap(({ payload: appKey, meta: { update } }) => {
+                const fetch$ = from(provider.getAppManifest(appKey)).pipe(
+                    filter((x) => !!x),
+                    map((manifest) => actions.setManifest(manifest, update)),
+                );
+                return merge(
+                    fetch$,
+                    fetch$.pipe(
+                        last(),
+                        map(({ payload }) => actions.fetchManifest.success(payload)),
+                    ),
+                ).pipe(
+                    catchError((err) => {
+                        return of(actions.fetchManifest.failure(err));
+                    }),
+                );
+            }),
+        );
+
+export const handleFetchConfig =
+    (provider: AppModuleProvider): Flow<Actions, AppBundleState> =>
+    (action$) =>
+        action$.pipe(
+            filter(actions.fetchConfig.match),
+            switchMap(({ payload: appKey }) => {
+                const fetch$ = from(provider.getAppConfig(appKey)).pipe(map(actions.setConfig));
+                return merge(
+                    fetch$,
+                    fetch$.pipe(
+                        last(),
+                        map(({ payload }) => actions.fetchConfig.success(payload)),
+                    ),
+                ).pipe(catchError((err) => of(actions.fetchConfig.failure(err))));
+            }),
+        );
+
+export const handleImportApplication = (): Flow<Actions, AppBundleState> => (action$) =>
+    action$.pipe(
+        filter(actions.importApp.match),
+        switchMap(({ payload }) => {
+            return from(import(payload)).pipe(
+                map(actions.importApp.success),
+                catchError((err) => of(actions.importApp.failure(err))),
+            );
+        }),
+    );

package/src/app/index.ts

@@ -0,0 +1,3 @@
+export { App, IApp } from './App';
+
+export { default } from './App';

package/src/app/types.ts

@@ -0,0 +1,17 @@
+import type { AppConfig, AppManifest, AppModulesInstance, AppScriptModule } from '../types';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AppBundleState<TConfig = any, TModules = any> = {
+    appKey: string;
+    status: Set<string>;
+    manifest?: AppManifest;
+    config?: AppConfig<TConfig>;
+    modules?: AppScriptModule;
+    instance?: AppModulesInstance<TModules>;
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type AppBundleStateInitial<TConfig = any, TModules = any> = Omit<
+    AppBundleState<TConfig, TModules>,
+    'status'
+>;

package/src/enable-app-module.ts

@@ -0,0 +1,21 @@
+import type { IModulesConfigurator } from '@equinor/fusion-framework-module';
+import type { AppConfigBuilderCallback } from './AppConfigBuilder';
+
+import { module } from './module';
+
+/**
+ * Method for enabling the Service module
+ * @param configurator - configuration object
+ */
+export const enableAppModule = (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    configurator: IModulesConfigurator<any, any>,
+    builder?: AppConfigBuilderCallback,
+): void => {
+    configurator.addConfig({
+        module,
+        configure: (appConfigurator) => {
+            builder && appConfigurator.addConfigBuilder(builder);
+        },
+    });
+};

package/src/errors.ts

@@ -0,0 +1,65 @@
+type AppErrorType = 'not_found' | 'unauthorized' | 'unknown';
+
+export class AppManifestError extends Error {
+    static fromHttpResponse(response: Response, options?: ErrorOptions) {
+        switch (response.status) {
+            case 401:
+                return new AppManifestError(
+                    'unauthorized',
+                    'failed to load application manifest, request not authorized',
+                    options,
+                );
+            case 404:
+                return new AppManifestError('not_found', 'application manifest not found', options);
+        }
+        return new AppManifestError(
+            'unknown',
+            `failed to load application manifest, status code ${response.status}`,
+            options,
+        );
+    }
+    constructor(
+        public readonly type: AppErrorType,
+        message?: string,
+        options?: ErrorOptions,
+    ) {
+        super(message, options);
+    }
+}
+
+export class AppConfigError extends Error {
+    static fromHttpResponse(response: Response, options?: ErrorOptions) {
+        switch (response.status) {
+            case 401:
+                return new AppConfigError(
+                    'unauthorized',
+                    'failed to load application config, request not authorized',
+                    options,
+                );
+            case 404:
+                return new AppConfigError('not_found', 'application config not found', options);
+        }
+        return new AppConfigError(
+            'unknown',
+            `failed to load application config, status code ${response.status}`,
+            options,
+        );
+    }
+    constructor(
+        public readonly type: AppErrorType,
+        message?: string,
+        options?: ErrorOptions,
+    ) {
+        super(message, options);
+    }
+}
+
+export class AppScriptModuleError extends Error {
+    constructor(
+        public readonly type: AppErrorType,
+        message?: string,
+        options?: ErrorOptions,
+    ) {
+        super(message, options);
+    }
+}

package/src/events.ts

@@ -0,0 +1,18 @@
+import { FrameworkEvent, FrameworkEventInit } from '@equinor/fusion-framework-module-event';
+import { App } from './app/App';
+
+import './app/events';
+
+declare module '@equinor/fusion-framework-module-event' {
+    interface FrameworkEventMap {
+        /** fired when the current selected application changes */
+        onCurrentAppChanged: FrameworkEvent<
+            FrameworkEventInit<{
+                /** current application  */
+                next?: App;
+                /** previous application */
+                previous?: App;
+            }>
+        >;
+    }
+}

package/src/helpers.ts

@@ -0,0 +1,4 @@
+import { AppManifest } from './types';
+
+export const compareAppManifest = <T extends AppManifest>(a?: T, b?: T): boolean =>
+    JSON.stringify(a) === JSON.stringify(b);

package/src/index.ts

@@ -0,0 +1,16 @@
+export {
+    AppModuleConfig,
+    AppConfigurator,
+    IAppConfigurator,
+    AppModuleConfig as IAppModuleConfig,
+} from './AppConfigurator';
+export { AppModuleProvider } from './AppModuleProvider';
+
+export { IApp } from './app/App';
+
+export * from './events';
+export * from './types';
+
+export { enableAppModule } from './enable-app-module';
+
+export { default, AppModule, module, moduleKey } from './module';

package/src/module.ts

@@ -0,0 +1,30 @@
+import { Module } from '@equinor/fusion-framework-module';
+import { ModuleDeps } from './types';
+
+import { IAppConfigurator, AppConfigurator } from './AppConfigurator';
+import { AppModuleProvider } from './AppModuleProvider';
+
+export const moduleKey = 'app';
+
+export type AppModule = Module<typeof moduleKey, AppModuleProvider, IAppConfigurator, ModuleDeps>;
+
+export const module: AppModule = {
+    name: moduleKey,
+    configure: () => new AppConfigurator(),
+    initialize: async (args) => {
+        const config = await (args.config as AppConfigurator).createConfig(args);
+        const event = await args.requireInstance('event').catch(() => undefined);
+        return new AppModuleProvider({ config, event });
+    },
+    dispose: (args) => {
+        (args.instance as unknown as AppModuleProvider).dispose();
+    },
+};
+
+export default module;
+
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        app: AppModule;
+    }
+}

package/src/types.ts

@@ -0,0 +1,95 @@
+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 type { MsalModule } from '@equinor/fusion-framework-module-msal';
+import type { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
+import IApp from './app';
+
+// TODO
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Fusion = any;
+
+export type AppEnv<TConfig = unknown, TProps = unknown> = {
+    basename?: string;
+    manifest?: AppManifest;
+    config?: AppConfig<TConfig>;
+    props?: TProps;
+};
+
+// TODO: change to module-services when new app service is created
+export type ModuleDeps = [HttpModule, ServiceDiscoveryModule, EventModule];
+
+export type AppType = 'standalone' | 'report' | 'launcher';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type CurrentApp<TModules extends Array<AnyModule> = [], TEnv = any> =
+    | IApp<TEnv, TModules>
+    | null
+    | undefined;
+
+export type AppAuth = {
+    clientId: string;
+    resources: string[];
+};
+
+type AppCategory = {
+    id?: string;
+    name: string | null;
+    color: string | null;
+    defaultIcon: string | null;
+};
+
+export type AppManifest = {
+    key: string;
+    name: string;
+    entry: string;
+    version: string;
+    shortName?: string;
+    description?: string;
+    type?: AppType;
+    tags?: string[];
+    // context?: ContextManifest;
+    auth?: AppAuth[];
+    icon?: string;
+    order?: number;
+    publishedDate?: Date;
+    accentColor?: string;
+    categoryId?: string;
+    category?: AppCategory;
+    hide?: boolean;
+};
+
+export type Endpoint = { name: string; uri: string; scopes?: string[] };
+
+export type AppConfig<TEnvironment = unknown> = {
+    environment: TEnvironment;
+    endpoints: Record<string, string | Endpoint>;
+};
+
+/**
+ * @template TEnvironment - name of hosted environment
+ * @template TModule - ES module type (import return type)
+ */
+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>>;

package/src/version.ts

@@ -0,0 +1,2 @@
+// Generated by genversion.
+export const version = '5.2.4';

package/tsconfig.json

@@ -0,0 +1,33 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist/esm",
+    "rootDir": "src",
+    "declarationDir": "./dist/types",
+    
+  },
+  "references": [
+    {
+      "path": "../../utils/query"
+    },
+    {
+      "path": "../module"
+    },
+    {
+      "path": "../http"
+    },
+    {
+      "path": "../event"
+    },
+    {
+      "path": "../service-discovery"
+    }
+  ],
+  "include": [
+    "src/**/*",
+  ],
+  "exclude": [
+    "node_modules",
+    "lib"
+  ]
+}