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

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

@@ -0,0 +1,70 @@
+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 { AppBundleState, AppBundleStateInitial } from './types';
+import './events';
+export declare function filterEmpty<T>(): OperatorFunction<T | null | undefined, T>;
+export interface IApp<TEnv = any, TModules extends Array<AnyModule> | unknown = unknown> {
+    get manifest$(): Observable<AppManifest>;
+    get config$(): Observable<AppConfig<TEnv>>;
+    get modules$(): Observable<AppScriptModule>;
+    get instance$(): Observable<AppModulesInstance<TModules>>;
+    get state(): AppBundleState;
+    get appKey(): string;
+    get manifest(): AppManifest | undefined;
+    get manifestAsync(): Promise<AppManifest>;
+    get config(): AppConfig<TEnv> | undefined;
+    get instance(): AppModulesInstance<TModules> | undefined;
+    initialize(): Observable<{
+        manifest: AppManifest;
+        script: AppScriptModule;
+        config: AppConfig;
+    }>;
+    loadConfig(): void;
+    loadManifest(): void;
+    loadAppModule(allow_cache?: boolean): 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>;
+}
+export declare class App<TEnv = any, TModules extends Array<AnyModule> | unknown = unknown> implements IApp<TEnv, TModules> {
+    #private;
+    get manifest$(): Observable<AppManifest>;
+    get config$(): Observable<AppConfig<TEnv>>;
+    get modules$(): Observable<AppScriptModule>;
+    get instance$(): Observable<AppModulesInstance<TModules>>;
+    get state(): AppBundleState;
+    get appKey(): string;
+    get manifest(): AppManifest | undefined;
+    get manifestAsync(): Promise<AppManifest>;
+    get config(): AppConfig<TEnv> | undefined;
+    get configAsync(): Promise<AppConfig<TEnv>>;
+    get instance(): AppModulesInstance<TModules> | undefined;
+    constructor(value: AppBundleStateInitial, args: {
+        provider: AppModuleProvider;
+        event?: ModuleType<EventModule>;
+    });
+    initialize(): Observable<{
+        manifest: AppManifest;
+        script: AppScriptModule;
+        config: AppConfig;
+    }>;
+    loadConfig(): void;
+    loadManifest(update?: boolean): void;
+    updateManifest(manifest: AppManifest, replace?: false): 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;
+}
+export default App;

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

@@ -0,0 +1,60 @@
+import { ActionInstanceMap, ActionTypes } from '@equinor/fusion-observable';
+import { AppConfig, AppManifest, AppModulesInstance, AppScriptModule } from '../types';
+declare const createActions: () => {
+    setManifest: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[manifest: AppManifest, update?: boolean | undefined], AppManifest, "set_manifest", never, {
+        created: number;
+        update: boolean | undefined;
+    }>;
+    fetchManifest: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[key: string, update?: boolean | undefined], string, "fetch_manifest::request", never, {
+        update: boolean | undefined;
+    }> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[manifest: AppManifest], AppManifest, "fetch_manifest::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "fetch_manifest::failure", never, never>;
+    };
+    setConfig: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[config: AppConfig], AppConfig, "set_config", never, never>;
+    fetchConfig: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[key: string], string, "fetch_config::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[config: AppConfig], AppConfig, "fetch_config::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "fetch_config::failure", never, never>;
+    };
+    setModule: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[module: any], any, "set_module", never, never>;
+    importApp: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[entrypoint: string], string, "import_app::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[module: AppScriptModule], AppScriptModule, "import_app::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "import_app::failure", never, never>;
+    };
+    setInstance: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[instance: AppModulesInstance], AppModulesInstance, "set_instance", never, never>;
+    initialize: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[], null, "initialize_app::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[], null, "initialize_app::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "initialize_app::failure", never, never>;
+    };
+};
+export declare const actions: {
+    setManifest: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[manifest: AppManifest, update?: boolean | undefined], AppManifest, "set_manifest", never, {
+        created: number;
+        update: boolean | undefined;
+    }>;
+    fetchManifest: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[key: string, update?: boolean | undefined], string, "fetch_manifest::request", never, {
+        update: boolean | undefined;
+    }> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[manifest: AppManifest], AppManifest, "fetch_manifest::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "fetch_manifest::failure", never, never>;
+    };
+    setConfig: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[config: AppConfig], AppConfig, "set_config", never, never>;
+    fetchConfig: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[key: string], string, "fetch_config::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[config: AppConfig], AppConfig, "fetch_config::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "fetch_config::failure", never, never>;
+    };
+    setModule: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[module: any], any, "set_module", never, never>;
+    importApp: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[entrypoint: string], string, "import_app::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[module: AppScriptModule], AppScriptModule, "import_app::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "import_app::failure", never, never>;
+    };
+    setInstance: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[instance: AppModulesInstance], AppModulesInstance, "set_instance", never, never>;
+    initialize: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[], null, "initialize_app::request", never, never> & {
+        success: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[], null, "initialize_app::success", never, never>;
+        failure: import("@equinor/fusion-observable").ActionCreatorWithPreparedPayload<[error: unknown], unknown, "initialize_app::failure", 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, AppBundleStateInitial } from './types';
+export declare const createReducer: (value: AppBundleStateInitial) => import("@equinor/fusion-observable").ReducerWithInitialState<AppBundleState, 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, AppBundleStateInitial } from './types';
+import type { AppModuleProvider } from '../AppModuleProvider';
+export declare const createState: (value: AppBundleStateInitial, provider: AppModuleProvider) => FlowSubject<AppBundleState, Actions>;

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

@@ -0,0 +1,28 @@
+import type { FrameworkEvent, FrameworkEventInit } from '@equinor/fusion-framework-module-event';
+import type { App } from './App';
+import type { AppConfig, AppManifest, AppModulesInstance } from '../types';
+export type AppEventEventInit<TDetail extends Record<string, unknown> | unknown = unknown> = FrameworkEventInit<TDetail & {
+    appKey: string;
+}, App>;
+declare module '@equinor/fusion-framework-module-event' {
+    interface FrameworkEventMap {
+        onAppModulesLoaded: FrameworkEvent<AppEventEventInit<{
+            modules: AppModulesInstance;
+        }>>;
+        onAppManifestLoaded: FrameworkEvent<AppEventEventInit<{
+            manifest: AppManifest;
+        }>>;
+        onAppConfigLoaded: FrameworkEvent<AppEventEventInit<{
+            config: AppConfig;
+        }>>;
+        onAppScriptLoaded: FrameworkEvent<AppEventEventInit<{
+            manifest: AppManifest;
+        }>>;
+        onAppInitialize: FrameworkEvent<AppEventEventInit>;
+        onAppInitialized: FrameworkEvent<AppEventEventInit>;
+        onAppInitializeFailed: FrameworkEvent<AppEventEventInit<{
+            error: unknown;
+        }>>;
+        onAppDispose: FrameworkEvent<AppEventEventInit>;
+    }
+}

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 type { 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/index.d.ts

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

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

@@ -0,0 +1,10 @@
+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>;
+};
+export type AppBundleStateInitial<TConfig = any, TModules = any> = Omit<AppBundleState<TConfig, TModules>, 'status'>;

package/dist/types/enable-app-module.d.ts

@@ -0,0 +1,3 @@
+import type { IModulesConfigurator } from '@equinor/fusion-framework-module';
+import type { AppConfigBuilderCallback } from './AppConfigBuilder';
+export declare const enableAppModule: (configurator: IModulesConfigurator<any, any>, builder?: AppConfigBuilderCallback) => void;

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,11 @@
+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 {
+        onCurrentAppChanged: FrameworkEvent<FrameworkEventInit<{
+            next?: App;
+            previous?: App;
+        }>>;
+    }
+}

package/dist/types/helpers.d.ts

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

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+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/dist/types/module.d.ts

@@ -0,0 +1,13 @@
+import { Module } from '@equinor/fusion-framework-module';
+import { ModuleDeps } from './types';
+import { IAppConfigurator } from './AppConfigurator';
+import { AppModuleProvider } from './AppModuleProvider';
+export declare const moduleKey = "app";
+export type AppModule = Module<typeof moduleKey, AppModuleProvider, IAppConfigurator, ModuleDeps>;
+export declare const module: AppModule;
+export default module;
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        app: AppModule;
+    }
+}

package/dist/types/types.d.ts

@@ -0,0 +1,73 @@
+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';
+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 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[];
+    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>;
+};
+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/dist/types/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "5.2.4";

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@equinor/fusion-framework-module-app",
+  "version": "0.0.0-next-20230915111233",
+  "description": "",
+  "main": "dist/esm/index.js",
+  "exports": {
+    ".": "./dist/esm/index.js",
+    "./errors.js": "./dist/esm/errors.js",
+    "./app": "./dist/esm/app/index.js"
+  },
+  "types": "dist/types/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "errors.js": [
+        "dist/types/errors.d.ts"
+      ],
+      "app": [
+        "dist/types/app/index.d.ts"
+      ]
+    }
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/equinor/fusion-framework.git",
+    "directory": "packages/modules/app"
+  },
+  "dependencies": {
+    "immer": "^9.0.16",
+    "rxjs": "^7.8.1",
+    "@equinor/fusion-observable": "^8.1.1",
+    "@equinor/fusion-query": "^0.0.0-next-20230915111233"
+  },
+  "devDependencies": {
+    "typescript": "^5.1.3",
+    "@equinor/fusion-framework-module-event": "^4.0.5",
+    "@equinor/fusion-framework-module-http": "^0.0.0-next-20230915111233",
+    "@equinor/fusion-framework-module-msal": "^3.0.6",
+    "@equinor/fusion-framework-module": "^4.2.4",
+    "@equinor/fusion-framework-module-service-discovery": "^0.0.0-next-20230915111233"
+  },
+  "scripts": {
+    "build": "tsc -b"
+  }
+}

package/src/AppConfigBuilder.ts

@@ -0,0 +1,89 @@
+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,104 @@
+import type { ModuleInitializerArgs } from '@equinor/fusion-framework-module';
+import type { HttpModule, IHttpClient } from '@equinor/fusion-framework-module-http';
+import type { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
+import type { 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: () => 'manifests',
+                    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;
+    }
+}