@tramvai/module-child-app 2.70.1 → 2.72.3

package/lib/server/preload.js

@@ -0,0 +1,81 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class PreloadManager {
+    constructor({ loader, runner, stateManager, resolutionConfigManager, resolveFullConfig, }) {
+        this.shouldRunImmediately = false;
+        this.map = new Map();
+        this.preloadMap = new Map();
+        this.loader = loader;
+        this.runner = runner;
+        this.stateManager = stateManager;
+        this.resolutionConfigManager = resolutionConfigManager;
+        this.resolveFullConfig = resolveFullConfig;
+    }
+    async preload(request) {
+        await this.resolutionConfigManager.init();
+        const config = this.resolveFullConfig(request);
+        if (!config) {
+            return;
+        }
+        const { key } = config;
+        if (this.map.has(key)) {
+            await this.map.get(key);
+            return;
+        }
+        const promise = this.loader
+            .load(config)
+            .catch(() => {
+            // Actual error will be logged by the internals of this.loader
+        })
+            .then(() => {
+            if (this.shouldRunImmediately) {
+                return this.run('customer', config);
+            }
+        })
+            .then(() => config);
+        this.map.set(key, promise);
+        this.preloadMap.set(config.key, config);
+        if (this.shouldRunImmediately) {
+            await promise;
+        }
+    }
+    isPreloaded(request) {
+        const config = this.resolveFullConfig(request);
+        return !!config && this.map.has(config.key);
+    }
+    async runPreloaded() {
+        this.shouldRunImmediately = true;
+        const promises = [];
+        this.map.forEach((childAppPromise) => {
+            promises.push((async () => {
+                await this.run('customer', await childAppPromise);
+            })());
+        });
+        await Promise.all(promises);
+    }
+    pageRender() { }
+    async clearPreloaded() {
+        const promises = [];
+        this.map.forEach((childAppPromise) => {
+            promises.push((async () => {
+                await this.run('clear', await childAppPromise);
+            })());
+        });
+        await Promise.all(promises);
+    }
+    getPreloadedList() {
+        return Array.from(this.preloadMap.values());
+    }
+    async run(status, config) {
+        const childApp = this.loader.get(config);
+        if (!childApp) {
+            return;
+        }
+        await this.runner.run('server', status, config);
+        await this.stateManager.registerChildApp(config);
+    }
+}
+
+exports.PreloadManager = PreloadManager;

package/lib/server/providers.es.js

@@ -0,0 +1,131 @@
+import { combineValidators, isUrl, endsWith } from '@tinkoff/env-validators';
+import { Scope } from '@tinkoff/dippy';
+import { provide, commandLineListTokens } from '@tramvai/core';
+import { ENV_USED_TOKEN, LOGGER_TOKEN, CREATE_CACHE_TOKEN, STORE_TOKEN } from '@tramvai/tokens-common';
+import { RESOURCES_REGISTRY, RENDER_SLOTS, ResourceType, ResourceSlot, EXTEND_RENDER } from '@tramvai/tokens-render';
+import { CHILD_APP_LOADER_TOKEN, CHILD_APP_STATE_MANAGER_TOKEN, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN } from '@tramvai/tokens-child-app';
+import { safeStringify } from '@tramvai/safe-strings';
+import { ServerLoader } from './loader.es.js';
+import { PreloadManager } from './preload.es.js';
+import { StateManager, executeRootStateSubscriptions } from './stateManager.es.js';
+import { setPreloaded } from '../shared/store.es.js';
+import { RenderManager } from './render.es.js';
+import { registerChildAppRenderSlots } from './render-slots.es.js';
+import { GLOBAL_CHILD_STATE } from '../shared/constants.es.js';
+
+const serverProviders = [
+    provide({
+        provide: ENV_USED_TOKEN,
+        multi: true,
+        useValue: [
+            {
+                key: 'CHILD_APP_EXTERNAL_URL',
+                optional: true,
+                validator: combineValidators([isUrl, endsWith('/')]),
+            },
+        ],
+    }),
+    provide({
+        provide: CHILD_APP_LOADER_TOKEN,
+        useClass: ServerLoader,
+        scope: Scope.SINGLETON,
+        deps: {
+            logger: LOGGER_TOKEN,
+            createCache: CREATE_CACHE_TOKEN,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_STATE_MANAGER_TOKEN,
+        useClass: StateManager,
+        deps: {
+            logger: LOGGER_TOKEN,
+            diManager: CHILD_APP_DI_MANAGER_TOKEN,
+            resourcesRegistry: RESOURCES_REGISTRY,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+        useClass: PreloadManager,
+        deps: {
+            loader: CHILD_APP_LOADER_TOKEN,
+            runner: CHILD_APP_COMMAND_LINE_RUNNER_TOKEN,
+            stateManager: CHILD_APP_STATE_MANAGER_TOKEN,
+            resolutionConfigManager: CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN,
+            resolveFullConfig: CHILD_APP_RESOLVE_CONFIG_TOKEN,
+        },
+    }),
+    provide({
+        provide: RENDER_SLOTS,
+        multi: true,
+        useFactory: ({ stateManager, preloader, store }) => {
+            store.dispatch(setPreloaded(preloader.getPreloadedList()));
+            return {
+                type: ResourceType.asIs,
+                slot: ResourceSlot.BODY_END,
+                payload: `<script id="${GLOBAL_CHILD_STATE}" type="application/json">${safeStringify(stateManager.getState())}</script>`,
+            };
+        },
+        deps: {
+            stateManager: CHILD_APP_STATE_MANAGER_TOKEN,
+            preloader: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+            store: STORE_TOKEN,
+        },
+    }),
+    provide({
+        provide: RENDER_SLOTS,
+        multi: true,
+        useFactory: registerChildAppRenderSlots,
+        deps: {
+            logger: LOGGER_TOKEN,
+            diManager: CHILD_APP_DI_MANAGER_TOKEN,
+            resolveFullConfig: CHILD_APP_RESOLVE_CONFIG_TOKEN,
+            preloadManager: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: EXTEND_RENDER,
+        multi: true,
+        // execute subscription right before render to get the last actual data
+        useFactory: executeRootStateSubscriptions,
+        deps: {
+            store: STORE_TOKEN,
+            diManager: CHILD_APP_DI_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_RENDER_MANAGER_TOKEN,
+        useClass: RenderManager,
+        deps: {
+            logger: LOGGER_TOKEN,
+            diManager: CHILD_APP_DI_MANAGER_TOKEN,
+            preloadManager: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+            resolveFullConfig: CHILD_APP_RESOLVE_CONFIG_TOKEN,
+        },
+    }),
+    provide({
+        provide: commandLineListTokens.resolvePageDeps,
+        multi: true,
+        useFactory: ({ preloader }) => {
+            return function childAppRunPreloaded() {
+                return preloader.runPreloaded();
+            };
+        },
+        deps: {
+            preloader: CHILD_APP_PRELOAD_MANAGER_TOKEN,
+        },
+    }),
+    provide({
+        provide: commandLineListTokens.clear,
+        multi: true,
+        useFactory: ({ renderManager }) => {
+            return function childAppRenderClear() {
+                renderManager.clear();
+            };
+        },
+        deps: {
+            renderManager: CHILD_APP_RENDER_MANAGER_TOKEN,
+        },
+    }),
+];
+
+export { serverProviders };

package/lib/server/providers.js

@@ -0,0 +1,135 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var envValidators = require('@tinkoff/env-validators');
+var dippy = require('@tinkoff/dippy');
+var core = require('@tramvai/core');
+var tokensCommon = require('@tramvai/tokens-common');
+var tokensRender = require('@tramvai/tokens-render');
+var tokensChildApp = require('@tramvai/tokens-child-app');
+var safeStrings = require('@tramvai/safe-strings');
+var loader = require('./loader.js');
+var preload = require('./preload.js');
+var stateManager = require('./stateManager.js');
+var store = require('../shared/store.js');
+var render = require('./render.js');
+var renderSlots = require('./render-slots.js');
+var constants = require('../shared/constants.js');
+
+const serverProviders = [
+    core.provide({
+        provide: tokensCommon.ENV_USED_TOKEN,
+        multi: true,
+        useValue: [
+            {
+                key: 'CHILD_APP_EXTERNAL_URL',
+                optional: true,
+                validator: envValidators.combineValidators([envValidators.isUrl, envValidators.endsWith('/')]),
+            },
+        ],
+    }),
+    core.provide({
+        provide: tokensChildApp.CHILD_APP_LOADER_TOKEN,
+        useClass: loader.ServerLoader,
+        scope: dippy.Scope.SINGLETON,
+        deps: {
+            logger: tokensCommon.LOGGER_TOKEN,
+            createCache: tokensCommon.CREATE_CACHE_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokensChildApp.CHILD_APP_STATE_MANAGER_TOKEN,
+        useClass: stateManager.StateManager,
+        deps: {
+            logger: tokensCommon.LOGGER_TOKEN,
+            diManager: tokensChildApp.CHILD_APP_DI_MANAGER_TOKEN,
+            resourcesRegistry: tokensRender.RESOURCES_REGISTRY,
+        },
+    }),
+    core.provide({
+        provide: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
+        useClass: preload.PreloadManager,
+        deps: {
+            loader: tokensChildApp.CHILD_APP_LOADER_TOKEN,
+            runner: tokensChildApp.CHILD_APP_COMMAND_LINE_RUNNER_TOKEN,
+            stateManager: tokensChildApp.CHILD_APP_STATE_MANAGER_TOKEN,
+            resolutionConfigManager: tokensChildApp.CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN,
+            resolveFullConfig: tokensChildApp.CHILD_APP_RESOLVE_CONFIG_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokensRender.RENDER_SLOTS,
+        multi: true,
+        useFactory: ({ stateManager, preloader, store: store$1 }) => {
+            store$1.dispatch(store.setPreloaded(preloader.getPreloadedList()));
+            return {
+                type: tokensRender.ResourceType.asIs,
+                slot: tokensRender.ResourceSlot.BODY_END,
+                payload: `<script id="${constants.GLOBAL_CHILD_STATE}" type="application/json">${safeStrings.safeStringify(stateManager.getState())}</script>`,
+            };
+        },
+        deps: {
+            stateManager: tokensChildApp.CHILD_APP_STATE_MANAGER_TOKEN,
+            preloader: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
+            store: tokensCommon.STORE_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokensRender.RENDER_SLOTS,
+        multi: true,
+        useFactory: renderSlots.registerChildAppRenderSlots,
+        deps: {
+            logger: tokensCommon.LOGGER_TOKEN,
+            diManager: tokensChildApp.CHILD_APP_DI_MANAGER_TOKEN,
+            resolveFullConfig: tokensChildApp.CHILD_APP_RESOLVE_CONFIG_TOKEN,
+            preloadManager: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokensRender.EXTEND_RENDER,
+        multi: true,
+        // execute subscription right before render to get the last actual data
+        useFactory: stateManager.executeRootStateSubscriptions,
+        deps: {
+            store: tokensCommon.STORE_TOKEN,
+            diManager: tokensChildApp.CHILD_APP_DI_MANAGER_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokensChildApp.CHILD_APP_RENDER_MANAGER_TOKEN,
+        useClass: render.RenderManager,
+        deps: {
+            logger: tokensCommon.LOGGER_TOKEN,
+            diManager: tokensChildApp.CHILD_APP_DI_MANAGER_TOKEN,
+            preloadManager: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
+            resolveFullConfig: tokensChildApp.CHILD_APP_RESOLVE_CONFIG_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: core.commandLineListTokens.resolvePageDeps,
+        multi: true,
+        useFactory: ({ preloader }) => {
+            return function childAppRunPreloaded() {
+                return preloader.runPreloaded();
+            };
+        },
+        deps: {
+            preloader: tokensChildApp.CHILD_APP_PRELOAD_MANAGER_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: core.commandLineListTokens.clear,
+        multi: true,
+        useFactory: ({ renderManager }) => {
+            return function childAppRenderClear() {
+                renderManager.clear();
+            };
+        },
+        deps: {
+            renderManager: tokensChildApp.CHILD_APP_RENDER_MANAGER_TOKEN,
+        },
+    }),
+];
+
+exports.serverProviders = serverProviders;

package/lib/server/render-slots.es.js

@@ -0,0 +1,50 @@
+import { ResourceType, ResourceSlot, RENDER_SLOTS } from '@tramvai/tokens-render';
+
+const registerChildAppRenderSlots = ({ logger, diManager, resolveFullConfig, preloadManager, }) => {
+    const log = logger('child-app:render:slots');
+    const result = [];
+    preloadManager.getPreloadedList().forEach((requestConfig) => {
+        var _a;
+        const config = resolveFullConfig(requestConfig);
+        if (!config) {
+            return;
+        }
+        const di = diManager.getChildDi(config);
+        result.push({
+            type: ResourceType.script,
+            slot: ResourceSlot.HEAD_CORE_SCRIPTS,
+            payload: config.client.entry,
+            attrs: {
+                'data-critical': 'true',
+            },
+        });
+        if (config.css) {
+            result.push({
+                type: ResourceType.style,
+                slot: ResourceSlot.HEAD_CORE_STYLES,
+                payload: (_a = config.css.entry) !== null && _a !== void 0 ? _a : null,
+                attrs: {
+                    'data-critical': 'true',
+                },
+            });
+        }
+        if (!di) {
+            return;
+        }
+        try {
+            const renderSlots = di.get({ token: RENDER_SLOTS, optional: true });
+            if (renderSlots) {
+                result.push(...renderSlots);
+            }
+        }
+        catch (error) {
+            log.error({
+                event: 'get-slots-failed',
+                config: requestConfig,
+            });
+        }
+    });
+    return result;
+};
+
+export { registerChildAppRenderSlots };

package/lib/server/render-slots.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tokensRender = require('@tramvai/tokens-render');
+
+const registerChildAppRenderSlots = ({ logger, diManager, resolveFullConfig, preloadManager, }) => {
+    const log = logger('child-app:render:slots');
+    const result = [];
+    preloadManager.getPreloadedList().forEach((requestConfig) => {
+        var _a;
+        const config = resolveFullConfig(requestConfig);
+        if (!config) {
+            return;
+        }
+        const di = diManager.getChildDi(config);
+        result.push({
+            type: tokensRender.ResourceType.script,
+            slot: tokensRender.ResourceSlot.HEAD_CORE_SCRIPTS,
+            payload: config.client.entry,
+            attrs: {
+                'data-critical': 'true',
+            },
+        });
+        if (config.css) {
+            result.push({
+                type: tokensRender.ResourceType.style,
+                slot: tokensRender.ResourceSlot.HEAD_CORE_STYLES,
+                payload: (_a = config.css.entry) !== null && _a !== void 0 ? _a : null,
+                attrs: {
+                    'data-critical': 'true',
+                },
+            });
+        }
+        if (!di) {
+            return;
+        }
+        try {
+            const renderSlots = di.get({ token: tokensRender.RENDER_SLOTS, optional: true });
+            if (renderSlots) {
+                result.push(...renderSlots);
+            }
+        }
+        catch (error) {
+            log.error({
+                event: 'get-slots-failed',
+                config: requestConfig,
+            });
+        }
+    });
+    return result;
+};
+
+exports.registerChildAppRenderSlots = registerChildAppRenderSlots;

package/lib/server/render.es.js

@@ -0,0 +1,39 @@
+class RenderManager {
+    constructor({ logger, preloadManager, diManager, resolveFullConfig, }) {
+        this.hasRenderedSet = new Set();
+        this.log = logger('child-app:render');
+        this.preloadManager = preloadManager;
+        this.diManager = diManager;
+        this.resolveFullConfig = resolveFullConfig;
+    }
+    getChildDi(request) {
+        const config = this.resolveFullConfig(request);
+        if (!config) {
+            throw new Error(`Child app "${request.name}" not found`);
+        }
+        this.hasRenderedSet.add(config.key);
+        if (this.preloadManager.isPreloaded(request)) {
+            return [this.diManager.getChildDi(config), undefined];
+        }
+        this.log.warn({
+            message: 'Child-app has been used but not preloaded before React render',
+            request,
+        });
+        return [undefined, undefined];
+    }
+    clear() {
+        const preloadedList = this.preloadManager.getPreloadedList();
+        for (const request of preloadedList) {
+            const config = this.resolveFullConfig(request);
+            if (!config || !this.hasRenderedSet.has(config.key)) {
+                this.log.warn({
+                    message: 'Child-app has been preloaded but not used in React render',
+                    request,
+                });
+            }
+        }
+        this.hasRenderedSet.clear();
+    }
+}
+
+export { RenderManager };

package/lib/server/render.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class RenderManager {
+    constructor({ logger, preloadManager, diManager, resolveFullConfig, }) {
+        this.hasRenderedSet = new Set();
+        this.log = logger('child-app:render');
+        this.preloadManager = preloadManager;
+        this.diManager = diManager;
+        this.resolveFullConfig = resolveFullConfig;
+    }
+    getChildDi(request) {
+        const config = this.resolveFullConfig(request);
+        if (!config) {
+            throw new Error(`Child app "${request.name}" not found`);
+        }
+        this.hasRenderedSet.add(config.key);
+        if (this.preloadManager.isPreloaded(request)) {
+            return [this.diManager.getChildDi(config), undefined];
+        }
+        this.log.warn({
+            message: 'Child-app has been used but not preloaded before React render',
+            request,
+        });
+        return [undefined, undefined];
+    }
+    clear() {
+        const preloadedList = this.preloadManager.getPreloadedList();
+        for (const request of preloadedList) {
+            const config = this.resolveFullConfig(request);
+            if (!config || !this.hasRenderedSet.has(config.key)) {
+                this.log.warn({
+                    message: 'Child-app has been preloaded but not used in React render',
+                    request,
+                });
+            }
+        }
+        this.hasRenderedSet.clear();
+    }
+}
+
+exports.RenderManager = RenderManager;

package/lib/server/stateManager.es.js

@@ -0,0 +1,49 @@
+import { CHILD_APP_INTERNAL_ROOT_STATE_SUBSCRIPTION_TOKEN } from '@tramvai/tokens-child-app';
+import { CONTEXT_TOKEN } from '@tramvai/tokens-common';
+
+const executeRootStateSubscriptions = ({ store, diManager, }) => {
+    return (render) => {
+        const state = store.getState();
+        diManager.forEachChildDi((di) => {
+            const subscriptions = di.get({
+                token: CHILD_APP_INTERNAL_ROOT_STATE_SUBSCRIPTION_TOKEN,
+                optional: true,
+            });
+            subscriptions === null || subscriptions === void 0 ? void 0 : subscriptions.forEach((sub) => {
+                sub.listener(state);
+            });
+        });
+        return render;
+    };
+};
+class StateManager {
+    constructor({ logger, diManager, }) {
+        this.state = Object.create(null);
+        this.log = logger('child-app:state-manager');
+        this.diManager = diManager;
+    }
+    registerChildApp(config) {
+        const di = this.diManager.getChildDi(config);
+        const { key } = config;
+        if (!di) {
+            return;
+        }
+        try {
+            const context = di.get(CONTEXT_TOKEN);
+            this.state[key] = context.dehydrate().dispatcher;
+        }
+        catch (error) {
+            if (error.code !== 'E_STUB') {
+                this.log.error({
+                    event: 'get-state-failed',
+                    config,
+                });
+            }
+        }
+    }
+    getState() {
+        return this.state;
+    }
+}
+
+export { StateManager, executeRootStateSubscriptions };

package/lib/server/stateManager.js

@@ -0,0 +1,54 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tokensChildApp = require('@tramvai/tokens-child-app');
+var tokensCommon = require('@tramvai/tokens-common');
+
+const executeRootStateSubscriptions = ({ store, diManager, }) => {
+    return (render) => {
+        const state = store.getState();
+        diManager.forEachChildDi((di) => {
+            const subscriptions = di.get({
+                token: tokensChildApp.CHILD_APP_INTERNAL_ROOT_STATE_SUBSCRIPTION_TOKEN,
+                optional: true,
+            });
+            subscriptions === null || subscriptions === void 0 ? void 0 : subscriptions.forEach((sub) => {
+                sub.listener(state);
+            });
+        });
+        return render;
+    };
+};
+class StateManager {
+    constructor({ logger, diManager, }) {
+        this.state = Object.create(null);
+        this.log = logger('child-app:state-manager');
+        this.diManager = diManager;
+    }
+    registerChildApp(config) {
+        const di = this.diManager.getChildDi(config);
+        const { key } = config;
+        if (!di) {
+            return;
+        }
+        try {
+            const context = di.get(tokensCommon.CONTEXT_TOKEN);
+            this.state[key] = context.dehydrate().dispatcher;
+        }
+        catch (error) {
+            if (error.code !== 'E_STUB') {
+                this.log.error({
+                    event: 'get-state-failed',
+                    config,
+                });
+            }
+        }
+    }
+    getState() {
+        return this.state;
+    }
+}
+
+exports.StateManager = StateManager;
+exports.executeRootStateSubscriptions = executeRootStateSubscriptions;