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

package/dist/types/AppConfigBuilder.d.ts

@@ -0,0 +1,26 @@
+import { ModuleInitializerArgs, Modules, ModuleType } from '@equinor/fusion-framework-module';
+import { QueryFn, QueryCtorOptions } from '@equinor/fusion-query';
+import { AppModuleConfig, IAppConfigurator } from './AppConfigurator';
+import type { AppConfig, AppManifest, ModuleDeps } from './types';
+export type AppConfigBuilderCallback = (builder: AppConfigBuilder<ModuleInitializerArgs<IAppConfigurator, any>>) => void | Promise<void>;
+export declare class AppConfigBuilder<TInit extends ModuleInitializerArgs<IAppConfigurator, any> = ModuleInitializerArgs<IAppConfigurator, ModuleDeps>> {
+    #private;
+    config: Partial<AppModuleConfig>;
+    constructor(init: TInit, config?: Partial<AppModuleConfig>);
+    requireInstance<TKey extends string = Extract<keyof Modules, string>>(module: TKey): Promise<ModuleType<Modules[TKey]>>;
+    requireInstance<T>(module: string): Promise<T>;
+    setAppClient(client: {
+        getAppManifest: QueryFn<AppManifest, {
+            appKey: string;
+        }> | QueryCtorOptions<AppManifest, {
+            appKey: string;
+        }>;
+        getAppManifests: QueryFn<AppManifest[], void> | QueryCtorOptions<AppManifest[], void>;
+        getAppConfig: QueryFn<AppConfig, {
+            appKey: string;
+        }> | QueryCtorOptions<AppConfig, {
+            appKey: string;
+            tag?: string;
+        }>;
+    }, expire?: number): void;
+}

package/dist/types/AppConfigurator.d.ts

@@ -0,0 +1,28 @@
+import { ModuleInitializerArgs } from '@equinor/fusion-framework-module';
+import { HttpModule, IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
+import { QueryCtorOptions } from '@equinor/fusion-query';
+import { AppConfigBuilderCallback } from './AppConfigBuilder';
+import type { AppConfig, AppManifest } from './types';
+export interface AppModuleConfig {
+    client: {
+        getAppManifest: QueryCtorOptions<AppManifest, {
+            appKey: string;
+        }>;
+        getAppManifests: QueryCtorOptions<AppManifest[], void>;
+        getAppConfig: QueryCtorOptions<AppConfig, {
+            appKey: string;
+            tag?: string;
+        }>;
+    };
+}
+export interface IAppConfigurator {
+    addConfigBuilder: (init: AppConfigBuilderCallback) => void;
+}
+export declare class AppConfigurator implements IAppConfigurator {
+    #private;
+    defaultExpireTime: number;
+    addConfigBuilder(init: AppConfigBuilderCallback): void;
+    protected _createHttpClient(init: ModuleInitializerArgs<IAppConfigurator, [HttpModule, ServiceDiscoveryModule]>): Promise<IHttpClient>;
+    createConfig(init: ModuleInitializerArgs<IAppConfigurator, [HttpModule, ServiceDiscoveryModule]>): Promise<AppModuleConfig>;
+}

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 './AppConfigurator';
+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/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 { AppModuleConfig, AppConfigurator, IAppConfigurator, AppModuleConfig as IAppModuleConfig, } from './AppConfigurator';
+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 { IAppConfigurator } from './AppConfigurator';
+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>;
 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.3.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": "4bc7a862d19921fc8801e5238d7013b8ece12917"
 }

package/src/AppConfigBuilder.ts

@@ -0,0 +1,86 @@
+import { ModuleInitializerArgs, Modules, ModuleType } from '@equinor/fusion-framework-module';
+import { QueryFn, QueryCtorOptions } from '@equinor/fusion-query';
+
+import { AppModuleConfig, IAppConfigurator } from './AppConfigurator';
+
+import type { AppConfig, AppManifest, ModuleDeps } from './types';
+
+export type AppConfigBuilderCallback = (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    builder: AppConfigBuilder<ModuleInitializerArgs<IAppConfigurator, any>>
+) => void | Promise<void>;
+
+export class AppConfigBuilder<
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    TInit extends ModuleInitializerArgs<IAppConfigurator, any> = ModuleInitializerArgs<
+        IAppConfigurator,
+        ModuleDeps
+    >
+> {
+    #init: TInit;
+    constructor(init: TInit, public config: Partial<AppModuleConfig> = {}) {
+        this.#init = init;
+    }
+
+    requireInstance<TKey extends string = Extract<keyof Modules, string>>(
+        module: TKey
+    ): Promise<ModuleType<Modules[TKey]>>;
+
+    requireInstance<T>(module: string): Promise<T>;
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    requireInstance(module: string): Promise<any> {
+        return this.#init.requireInstance(module);
+    }
+
+    setAppClient(
+        client: {
+            getAppManifest:
+                | QueryFn<AppManifest, { appKey: string }>
+                | QueryCtorOptions<AppManifest, { appKey: string }>;
+            getAppManifests: QueryFn<AppManifest[], void> | QueryCtorOptions<AppManifest[], void>;
+            getAppConfig:
+                | QueryFn<AppConfig, { appKey: string }>
+                | QueryCtorOptions<AppConfig, { appKey: string; tag?: string }>;
+        },
+        expire = 1 * 60 * 1000
+    ) {
+        client;
+        expire;
+
+        this.config.client = {
+            getAppManifest:
+                typeof client.getAppManifest === 'function'
+                    ? {
+                          key: ({ appKey }) => appKey,
+                          client: {
+                              fn: client.getAppManifest,
+                          },
+                          expire,
+                      }
+                    : client.getAppManifest,
+            getAppManifests:
+                typeof client.getAppManifests === 'function'
+                    ? {
+                          // TODO - might cast to checksum
+                          key: () => 'app_manifests',
+                          client: {
+                              fn: client.getAppManifests,
+                          },
+                          expire,
+                      }
+                    : client.getAppManifests,
+            getAppConfig:
+                typeof client.getAppConfig === 'function'
+                    ? {
+                          // TODO - might cast to checksum
+                          key: (args) => JSON.stringify(args),
+                          client: {
+                              fn: client.getAppConfig,
+                          },
+                          expire,
+                      }
+                    : client.getAppConfig,
+        };
+    }
+}

package/src/AppConfigurator.ts

@@ -0,0 +1,101 @@
+import { ModuleInitializerArgs } from '@equinor/fusion-framework-module';
+import { HttpModule, IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
+import { QueryCtorOptions } from '@equinor/fusion-query';
+
+import { AppConfigBuilder, AppConfigBuilderCallback } from './AppConfigBuilder';
+
+import { moduleKey } from './module';
+
+import type { AppConfig, AppManifest } from './types';
+
+export interface AppModuleConfig {
+    client: {
+        getAppManifest: QueryCtorOptions<AppManifest, { appKey: string }>;
+        getAppManifests: QueryCtorOptions<AppManifest[], void>;
+        getAppConfig: QueryCtorOptions<AppConfig, { appKey: string; tag?: string }>;
+    };
+}
+
+export interface IAppConfigurator {
+    addConfigBuilder: (init: AppConfigBuilderCallback) => void;
+}
+
+export class AppConfigurator implements IAppConfigurator {
+    defaultExpireTime = 1 * 60 * 1000;
+
+    #configBuilders: Array<AppConfigBuilderCallback> = [];
+
+    addConfigBuilder(init: AppConfigBuilderCallback): void {
+        this.#configBuilders.push(init);
+    }
+
+    /**
+     * WARNING: this function will be remove in future
+     */
+    protected async _createHttpClient(
+        init: ModuleInitializerArgs<IAppConfigurator, [HttpModule, ServiceDiscoveryModule]>
+    ): Promise<IHttpClient> {
+        const http = await init.requireInstance('http');
+        /** check if the http provider has configure a client */
+        if (http.hasClient(moduleKey)) {
+            return http.createClient(moduleKey);
+        } else {
+            /** load service discovery module */
+            const serviceDiscovery = await init.requireInstance('serviceDiscovery');
+
+            // TODO - remove when refactor portal service!
+            /** resolve and create a client from discovery */
+            try {
+                return await serviceDiscovery.createClient('app');
+            } catch {
+                return await serviceDiscovery.createClient('portal');
+            }
+        }
+    }
+
+    public async createConfig(
+        init: ModuleInitializerArgs<IAppConfigurator, [HttpModule, ServiceDiscoveryModule]>
+    ): Promise<AppModuleConfig> {
+        const config = await this.#configBuilders.reduce(async (cur, cb) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const builder = new AppConfigBuilder(init, await cur);
+            await Promise.resolve(cb(builder));
+            return Object.assign(cur, builder.config);
+        }, Promise.resolve({} as Partial<AppModuleConfig>));
+
+        // TODO - make less lazy
+        config.client ??= await (async (): Promise<AppModuleConfig['client']> => {
+            const httpClient = await this._createHttpClient(init);
+            return {
+                getAppManifest: {
+                    client: {
+                        fn: ({ appKey }) => httpClient.json$<AppManifest>(`/api/apps/${appKey}`),
+                    },
+                    key: ({ appKey }) => appKey,
+                    expire: this.defaultExpireTime,
+                },
+                getAppManifests: {
+                    client: {
+                        fn: () => httpClient.json$(`/api/apps`),
+                    },
+                    // TODO - might cast to checksum
+                    key: (args) => JSON.stringify(args),
+                    expire: this.defaultExpireTime,
+                },
+                getAppConfig: {
+                    client: {
+                        fn: ({ appKey, tag }) =>
+                            httpClient.json$(
+                                `/api/apps/${appKey}/config${tag ? `?tag=${tag}` : ''}`
+                            ),
+                    },
+                    key: (args) => JSON.stringify(args),
+                    expire: this.defaultExpireTime,
+                },
+            };
+        })();
+
+        return config as AppModuleConfig;
+    }
+}