@tramvai/module-child-app 5.53.80 → 6.62.0

package/lib/server/cache/cache.d.ts

@@ -0,0 +1,39 @@
+/// <reference types="node" />
+import { Cache } from '@tramvai/tokens-common';
+export declare const cache: (import("@tramvai/core").Provider<{
+    cacheCleanupConfig: {
+        token: {
+            cleanupIntervalMs?: number | undefined;
+        } & {
+            __type?: "base token" | undefined;
+        };
+        optional: true;
+    };
+    childAppLoaderCache: Cache<any> & {
+        __type?: "base token" | undefined;
+    };
+}, import("@tramvai/core").Command & {
+    __type?: "multi token" | undefined;
+}> | import("@tramvai/core").Provider<{
+    asyncLocalStorage: {
+        token: import("async_hooks").AsyncLocalStorage<import("@tramvai/tokens-common").AsyncLocalStorageState> & {
+            __type?: "base token" | undefined;
+        };
+        optional: true;
+    };
+    cacheOptions: {
+        token: {
+            max?: number | undefined;
+            ttl?: number | undefined;
+        } & {
+            __type?: "base token" | undefined;
+        };
+        optional: true;
+    };
+    createCache: import("@tramvai/tokens-common").CacheFactory & {
+        __type?: "base token" | undefined;
+    };
+}, Cache<any> & {
+    __type?: "base token" | undefined;
+}>)[];
+//# sourceMappingURL=cache.d.ts.map

package/lib/server/cache/cache.es.js

@@ -0,0 +1,76 @@
+import { provide, commandLineListTokens } from '@tramvai/core';
+import { optional, Scope } from '@tinkoff/dippy';
+import { CHILD_APP_LOADER_CACHE_CLEANUP_CONFIG_TOKEN, CHILD_APP_LOADER_CACHE_TOKEN, CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN } from '@tramvai/tokens-child-app';
+import { ASYNC_LOCAL_STORAGE_TOKEN, CREATE_CACHE_TOKEN } from '@tramvai/tokens-common';
+import { setCacheCleanupInterval } from './cacheCleanup.es.js';
+
+const cache = [
+    provide({
+        provide: commandLineListTokens.listen,
+        useFactory: ({ childAppLoaderCache, cacheCleanupConfig }) => {
+            return () => {
+                setCacheCleanupInterval(childAppLoaderCache, cacheCleanupConfig?.cleanupIntervalMs);
+            };
+        },
+        deps: {
+            cacheCleanupConfig: optional(CHILD_APP_LOADER_CACHE_CLEANUP_CONFIG_TOKEN),
+            childAppLoaderCache: CHILD_APP_LOADER_CACHE_TOKEN,
+        },
+    }),
+    provide({
+        provide: CHILD_APP_LOADER_CACHE_TOKEN,
+        scope: Scope.SINGLETON,
+        useFactory: ({ createCache, cacheOptions, asyncLocalStorage }) => {
+            const inMemoryCache = createCache('memory', {
+                name: 'child-app-loader',
+                // When Child App script is evicted from server loader cache, we get a small memory leak,
+                // because providers in singleton child DI, page components / actions, will store a reference to removed script,
+                // and server loader cache will contain a new instance of the same script.
+                //
+                // So, it is better to have bigger cache size to prevent evicting from cache,
+                // also for one Child App we need to save 3 elements - server JS, stats JSON and loadable stats JSON.
+                max: 100,
+                ttl: 1000 * 60 * 60 * 24 * 5,
+                ...cacheOptions,
+            });
+            let childAppLoaderCache = inMemoryCache;
+            // Cache is not compatible with HMR (Hot Module Replacement) because after HMR and page reload,
+            // we get the page from the cache. To solve this, we use Async Local Storage to ensure the
+            // cache is only valid within the context of a single request.
+            if (process.env.NODE_ENV === 'development' && !!asyncLocalStorage) {
+                childAppLoaderCache = {
+                    get(key) {
+                        if (key?.startsWith('__DEBUG__')) {
+                            const store = asyncLocalStorage.getStore();
+                            if (store) {
+                                return store[key];
+                            }
+                        }
+                        else {
+                            return inMemoryCache.get(key);
+                        }
+                    },
+                    set(key, module) {
+                        if (key?.startsWith('__DEBUG__')) {
+                            const store = asyncLocalStorage.getStore();
+                            if (store) {
+                                store[key] = module;
+                            }
+                        }
+                        else {
+                            inMemoryCache.set(key, module);
+                        }
+                    },
+                };
+            }
+            return childAppLoaderCache;
+        },
+        deps: {
+            asyncLocalStorage: optional(ASYNC_LOCAL_STORAGE_TOKEN),
+            cacheOptions: optional(CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN),
+            createCache: CREATE_CACHE_TOKEN,
+        },
+    }),
+];
+
+export { cache };

package/lib/server/cache/cache.js

@@ -0,0 +1,80 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+var dippy = require('@tinkoff/dippy');
+var tokensChildApp = require('@tramvai/tokens-child-app');
+var tokensCommon = require('@tramvai/tokens-common');
+var cacheCleanup = require('./cacheCleanup.js');
+
+const cache = [
+    core.provide({
+        provide: core.commandLineListTokens.listen,
+        useFactory: ({ childAppLoaderCache, cacheCleanupConfig }) => {
+            return () => {
+                cacheCleanup.setCacheCleanupInterval(childAppLoaderCache, cacheCleanupConfig?.cleanupIntervalMs);
+            };
+        },
+        deps: {
+            cacheCleanupConfig: dippy.optional(tokensChildApp.CHILD_APP_LOADER_CACHE_CLEANUP_CONFIG_TOKEN),
+            childAppLoaderCache: tokensChildApp.CHILD_APP_LOADER_CACHE_TOKEN,
+        },
+    }),
+    core.provide({
+        provide: tokensChildApp.CHILD_APP_LOADER_CACHE_TOKEN,
+        scope: dippy.Scope.SINGLETON,
+        useFactory: ({ createCache, cacheOptions, asyncLocalStorage }) => {
+            const inMemoryCache = createCache('memory', {
+                name: 'child-app-loader',
+                // When Child App script is evicted from server loader cache, we get a small memory leak,
+                // because providers in singleton child DI, page components / actions, will store a reference to removed script,
+                // and server loader cache will contain a new instance of the same script.
+                //
+                // So, it is better to have bigger cache size to prevent evicting from cache,
+                // also for one Child App we need to save 3 elements - server JS, stats JSON and loadable stats JSON.
+                max: 100,
+                ttl: 1000 * 60 * 60 * 24 * 5,
+                ...cacheOptions,
+            });
+            let childAppLoaderCache = inMemoryCache;
+            // Cache is not compatible with HMR (Hot Module Replacement) because after HMR and page reload,
+            // we get the page from the cache. To solve this, we use Async Local Storage to ensure the
+            // cache is only valid within the context of a single request.
+            if (process.env.NODE_ENV === 'development' && !!asyncLocalStorage) {
+                childAppLoaderCache = {
+                    get(key) {
+                        if (key?.startsWith('__DEBUG__')) {
+                            const store = asyncLocalStorage.getStore();
+                            if (store) {
+                                return store[key];
+                            }
+                        }
+                        else {
+                            return inMemoryCache.get(key);
+                        }
+                    },
+                    set(key, module) {
+                        if (key?.startsWith('__DEBUG__')) {
+                            const store = asyncLocalStorage.getStore();
+                            if (store) {
+                                store[key] = module;
+                            }
+                        }
+                        else {
+                            inMemoryCache.set(key, module);
+                        }
+                    },
+                };
+            }
+            return childAppLoaderCache;
+        },
+        deps: {
+            asyncLocalStorage: dippy.optional(tokensCommon.ASYNC_LOCAL_STORAGE_TOKEN),
+            cacheOptions: dippy.optional(tokensChildApp.CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN),
+            createCache: tokensCommon.CREATE_CACHE_TOKEN,
+        },
+    }),
+];
+
+exports.cache = cache;

package/lib/server/cache/cacheCleanup.d.ts

@@ -0,0 +1,4 @@
+import { Cache } from '@tramvai/tokens-common';
+export declare function cleanupStaleElementsInCache<T>(cache: Cache<T>): void;
+export declare function setCacheCleanupInterval<T>(cache: Cache<T>, intervalMs?: number): void;
+//# sourceMappingURL=cacheCleanup.d.ts.map

package/lib/server/cache/cacheCleanup.es.js

@@ -0,0 +1,16 @@
+function cleanupStaleElementsInCache(cache) {
+    const entries = cache.dump();
+    const now = Date.now();
+    for (const [key, value] of entries) {
+        if (value.start + value.ttl < now) {
+            cache.delete(key);
+        }
+    }
+}
+function setCacheCleanupInterval(cache, intervalMs = 1000 * 60 * 60 * 24) {
+    setInterval(() => {
+        cleanupStaleElementsInCache(cache);
+    }, intervalMs);
+}
+
+export { cleanupStaleElementsInCache, setCacheCleanupInterval };

package/lib/server/cache/cacheCleanup.js

@@ -0,0 +1,21 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function cleanupStaleElementsInCache(cache) {
+    const entries = cache.dump();
+    const now = Date.now();
+    for (const [key, value] of entries) {
+        if (value.start + value.ttl < now) {
+            cache.delete(key);
+        }
+    }
+}
+function setCacheCleanupInterval(cache, intervalMs = 1000 * 60 * 60 * 24) {
+    setInterval(() => {
+        cleanupStaleElementsInCache(cache);
+    }, intervalMs);
+}
+
+exports.cleanupStaleElementsInCache = cleanupStaleElementsInCache;
+exports.setCacheCleanupInterval = setCacheCleanupInterval;

package/lib/server/loader.d.ts

@@ -1,6 +1,6 @@
 import type { CHILD_APP_LOADER_PLUGIN, ChildApp } from '@tramvai/child-app-core';
-import { CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN, type ChildAppFinalConfig } from '@tramvai/tokens-child-app';
-import type { CREATE_CACHE_TOKEN, LOGGER_TOKEN, ENV_MANAGER_TOKEN, ASYNC_LOCAL_STORAGE_TOKEN } from '@tramvai/tokens-common';
+import { CHILD_APP_LOADER_CACHE_TOKEN, type ChildAppFinalConfig } from '@tramvai/tokens-child-app';
+import type { LOGGER_TOKEN, ENV_MANAGER_TOKEN } from '@tramvai/tokens-common';
 import { AsyncTapableHookInstance, TAPABLE_HOOK_FACTORY_TOKEN } from '@tramvai/core';
 import { Loader } from '../shared/loader';
 import type { LoadableStats, ModuleFederationStats } from '../shared/webpack/moduleFederation';
@@ -12,13 +12,11 @@ export declare class ServerLoader extends Loader {
     loadModuleHook: AsyncTapableHookInstance<{
         config: ChildAppFinalConfig;
     }, ChildApp | undefined>;
-    constructor({ logger, createCache, envManager, cacheOptions, asyncLocalStorage, hookFactory, plugins, }: {
+    constructor({ logger, envManager, cache, hookFactory, plugins, }: {
         hookFactory: typeof TAPABLE_HOOK_FACTORY_TOKEN;
         logger: typeof LOGGER_TOKEN;
-        createCache: typeof CREATE_CACHE_TOKEN;
         envManager: typeof ENV_MANAGER_TOKEN;
-        cacheOptions: typeof CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN | null;
-        asyncLocalStorage: typeof ASYNC_LOCAL_STORAGE_TOKEN | null;
+        cache: typeof CHILD_APP_LOADER_CACHE_TOKEN;
         plugins: (typeof CHILD_APP_LOADER_PLUGIN)[] | null;
     });
     private loadModule;

package/lib/server/loader.es.js

@@ -9,56 +9,12 @@ class ServerLoader extends Loader {
     log;
     hookFactory;
     loadModuleHook;
-    constructor({ logger, createCache, envManager, cacheOptions, asyncLocalStorage, hookFactory, plugins, }) {
+    constructor({ logger, envManager, cache, hookFactory, plugins, }) {
         super();
         this.hookFactory = hookFactory;
-        const cache = createCache('memory', {
-            name: 'child-app-loader',
-            ttl: 1000 * 60 * 60 * 24 * 5,
-            // When Child App script is evicted from server loader cache, we get a small memory leak,
-            // because providers in singleton child DI, page components / actions, will store a reference to removed script,
-            // and server loader cache will contain a new instance of the same script.
-            //
-            // So, it is better to have bigger cache size to prevent evicting from cache,
-            // also for one Child App we need to save 3 elements - server JS, stats JSON and loadable stats JSON.
-            //
-            // TODO: cache cleanup for previous versions of Child Apps
-            max: 100,
-            ...cacheOptions,
-        });
-        let internalLoadCache = cache;
-        // Cache is not compatible with HMR (Hot Module Replacement) because after HMR and page reload,
-        // we get the page from the cache. To solve this, we use Async Local Storage to ensure the
-        // cache is only valid within the context of a single request.
-        if (process.env.NODE_ENV === 'development' && !!asyncLocalStorage) {
-            internalLoadCache = {
-                get(key) {
-                    if (key?.startsWith('__DEBUG__')) {
-                        const store = asyncLocalStorage.getStore();
-                        if (store) {
-                            return store[key];
-                        }
-                    }
-                    else {
-                        return cache.get(key);
-                    }
-                },
-                set(key, module) {
-                    if (key?.startsWith('__DEBUG__')) {
-                        const store = asyncLocalStorage.getStore();
-                        if (store) {
-                            store[key] = module;
-                        }
-                    }
-                    else {
-                        cache.set(key, module);
-                    }
-                },
-            };
-        }
         this.log = logger('child-app:loader');
         this.loader = new ServerLoader$1({
-            cache: internalLoadCache,
+            cache,
             log: this.log,
             requestOptions: {
                 circuitBreakerEnabled: isNil(envManager.get('HTTP_CLIENT_CIRCUIT_BREAKER_DISABLED')),
@@ -78,6 +34,7 @@ class ServerLoader extends Loader {
                 codePrefix: `var ASSETS_PREFIX="${config.client.baseUrl}";`,
                 displayName: config.name,
                 kind: 'child-app',
+                debug: config.tag === 'debug',
             }),
             this.loader
                 .resolveByUrl(config.client.stats, {
@@ -85,6 +42,7 @@ class ServerLoader extends Loader {
                 kind: 'child-app stats',
                 displayName: config.name,
                 silent: true,
+                debug: config.tag === 'debug',
             })
                 // we can live without stats
                 .catch(() => { }),
@@ -96,6 +54,7 @@ class ServerLoader extends Loader {
                 kind: 'child-app loadable stats',
                 displayName: config.name,
                 silent: true,
+                debug: config.tag === 'debug',
             })
                 // we can live without loadable stats, for backward compatibility is ok
                 // but hydration errors will occur when lazy component will loaded at client-side at demand
@@ -110,7 +69,9 @@ class ServerLoader extends Loader {
         return childApp;
     }
     async init(config) {
-        const container = this.loader.getByUrl(config.server.entry);
+        const container = this.loader.getByUrl(config.server.entry, {
+            debug: config.tag === 'debug',
+        });
         if (!container) {
             return;
         }
@@ -133,7 +94,9 @@ class ServerLoader extends Loader {
         }
     }
     get(config) {
-        const container = this.loader.getByUrl(config.server.entry);
+        const container = this.loader.getByUrl(config.server.entry, {
+            debug: config.tag === 'debug',
+        });
         if (!container) {
             return undefined;
         }
@@ -141,7 +104,9 @@ class ServerLoader extends Loader {
         return entry && this.resolve(entry);
     }
     getStats(config) {
-        return this.loader.getByUrl(config.client.stats);
+        return this.loader.getByUrl(config.client.stats, {
+            debug: config.tag === 'debug',
+        });
     }
     getLoadableStats(config) {
         if (!config.client.statsLoadable) {

package/lib/server/loader.js

@@ -17,56 +17,12 @@ class ServerLoader extends loader.Loader {
     log;
     hookFactory;
     loadModuleHook;
-    constructor({ logger, createCache, envManager, cacheOptions, asyncLocalStorage, hookFactory, plugins, }) {
+    constructor({ logger, envManager, cache, hookFactory, plugins, }) {
         super();
         this.hookFactory = hookFactory;
-        const cache = createCache('memory', {
-            name: 'child-app-loader',
-            ttl: 1000 * 60 * 60 * 24 * 5,
-            // When Child App script is evicted from server loader cache, we get a small memory leak,
-            // because providers in singleton child DI, page components / actions, will store a reference to removed script,
-            // and server loader cache will contain a new instance of the same script.
-            //
-            // So, it is better to have bigger cache size to prevent evicting from cache,
-            // also for one Child App we need to save 3 elements - server JS, stats JSON and loadable stats JSON.
-            //
-            // TODO: cache cleanup for previous versions of Child Apps
-            max: 100,
-            ...cacheOptions,
-        });
-        let internalLoadCache = cache;
-        // Cache is not compatible with HMR (Hot Module Replacement) because after HMR and page reload,
-        // we get the page from the cache. To solve this, we use Async Local Storage to ensure the
-        // cache is only valid within the context of a single request.
-        if (process.env.NODE_ENV === 'development' && !!asyncLocalStorage) {
-            internalLoadCache = {
-                get(key) {
-                    if (key?.startsWith('__DEBUG__')) {
-                        const store = asyncLocalStorage.getStore();
-                        if (store) {
-                            return store[key];
-                        }
-                    }
-                    else {
-                        return cache.get(key);
-                    }
-                },
-                set(key, module) {
-                    if (key?.startsWith('__DEBUG__')) {
-                        const store = asyncLocalStorage.getStore();
-                        if (store) {
-                            store[key] = module;
-                        }
-                    }
-                    else {
-                        cache.set(key, module);
-                    }
-                },
-            };
-        }
         this.log = logger('child-app:loader');
         this.loader = new moduleLoaderServer.ServerLoader({
-            cache: internalLoadCache,
+            cache,
             log: this.log,
             requestOptions: {
                 circuitBreakerEnabled: isNil__default["default"](envManager.get('HTTP_CLIENT_CIRCUIT_BREAKER_DISABLED')),
@@ -86,6 +42,7 @@ class ServerLoader extends loader.Loader {
                 codePrefix: `var ASSETS_PREFIX="${config.client.baseUrl}";`,
                 displayName: config.name,
                 kind: 'child-app',
+                debug: config.tag === 'debug',
             }),
             this.loader
                 .resolveByUrl(config.client.stats, {
@@ -93,6 +50,7 @@ class ServerLoader extends loader.Loader {
                 kind: 'child-app stats',
                 displayName: config.name,
                 silent: true,
+                debug: config.tag === 'debug',
             })
                 // we can live without stats
                 .catch(() => { }),
@@ -104,6 +62,7 @@ class ServerLoader extends loader.Loader {
                 kind: 'child-app loadable stats',
                 displayName: config.name,
                 silent: true,
+                debug: config.tag === 'debug',
             })
                 // we can live without loadable stats, for backward compatibility is ok
                 // but hydration errors will occur when lazy component will loaded at client-side at demand
@@ -118,7 +77,9 @@ class ServerLoader extends loader.Loader {
         return childApp;
     }
     async init(config) {
-        const container = this.loader.getByUrl(config.server.entry);
+        const container = this.loader.getByUrl(config.server.entry, {
+            debug: config.tag === 'debug',
+        });
         if (!container) {
             return;
         }
@@ -141,7 +102,9 @@ class ServerLoader extends loader.Loader {
         }
     }
     get(config) {
-        const container = this.loader.getByUrl(config.server.entry);
+        const container = this.loader.getByUrl(config.server.entry, {
+            debug: config.tag === 'debug',
+        });
         if (!container) {
             return undefined;
         }
@@ -149,7 +112,9 @@ class ServerLoader extends loader.Loader {
         return entry && this.resolve(entry);
     }
     getStats(config) {
-        return this.loader.getByUrl(config.client.stats);
+        return this.loader.getByUrl(config.client.stats, {
+            debug: config.tag === 'debug',
+        });
     }
     getLoadableStats(config) {
         if (!config.client.statsLoadable) {

package/lib/server/providers.es.js

@@ -1,9 +1,9 @@
 import { combineValidators, isUrl, endsWith } from '@tinkoff/env-validators';
 import { Scope, optional, DI_TOKEN } from '@tinkoff/dippy';
 import { provide, TAPABLE_HOOK_FACTORY_TOKEN, commandLineListTokens } from '@tramvai/core';
-import { ENV_USED_TOKEN, LOGGER_TOKEN, CREATE_CACHE_TOKEN, ENV_MANAGER_TOKEN, ASYNC_LOCAL_STORAGE_TOKEN, STORE_TOKEN } from '@tramvai/tokens-common';
+import { ENV_USED_TOKEN, LOGGER_TOKEN, ENV_MANAGER_TOKEN, STORE_TOKEN, ASYNC_LOCAL_STORAGE_TOKEN } from '@tramvai/tokens-common';
 import { RESOURCES_REGISTRY, RENDER_SLOTS, ResourceType, ResourceSlot, RENDER_FLOW_AFTER_TOKEN, REACT_SERVER_RENDER_MODE, EXTEND_RENDER } from '@tramvai/tokens-render';
-import { CHILD_APP_LOADER_TOKEN, CHILD_APP_LOADER_PLUGIN, CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN, CHILD_APP_STATE_MANAGER_TOKEN, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_PRELOAD_MANAGER_PLUGIN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN, CHILD_APP_CONTRACT_MANAGER, HOST_PROVIDED_CONTRACTS, HOST_REQUIRED_CONTRACTS } from '@tramvai/tokens-child-app';
+import { CHILD_APP_LOADER_TOKEN, CHILD_APP_LOADER_PLUGIN, CHILD_APP_LOADER_CACHE_TOKEN, CHILD_APP_STATE_MANAGER_TOKEN, CHILD_APP_DI_MANAGER_TOKEN, CHILD_APP_PRELOAD_MANAGER_TOKEN, CHILD_APP_PRELOAD_MANAGER_PLUGIN, CHILD_APP_COMMAND_LINE_RUNNER_TOKEN, CHILD_APP_RESOLUTION_CONFIG_MANAGER_TOKEN, CHILD_APP_RESOLVE_CONFIG_TOKEN, CHILD_APP_RENDER_MANAGER_TOKEN, CHILD_APP_CONTRACT_MANAGER, HOST_PROVIDED_CONTRACTS, HOST_REQUIRED_CONTRACTS } from '@tramvai/tokens-child-app';
 import { safeStringify } from '@tramvai/safe-strings';
 import { ServerLoader } from './loader.es.js';
 import { PreloadManager } from './preload.es.js';
@@ -13,8 +13,10 @@ import { RenderManager } from './render.es.js';
 import { registerChildAppRenderSlots } from './render-slots.es.js';
 import { GLOBAL_CHILD_STATE } from '../shared/constants.es.js';
 import { ChildAppContractManager } from '../contracts/contractManager.server.es.js';
+import { cache } from './cache/cache.es.js';
 
 const serverProviders = [
+    ...cache,
     provide({
         provide: ENV_USED_TOKEN,
         multi: true,
@@ -37,10 +39,8 @@ const serverProviders = [
             },
             hookFactory: TAPABLE_HOOK_FACTORY_TOKEN,
             logger: LOGGER_TOKEN,
-            createCache: CREATE_CACHE_TOKEN,
-            cacheOptions: optional(CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN),
+            cache: CHILD_APP_LOADER_CACHE_TOKEN,
             envManager: ENV_MANAGER_TOKEN,
-            asyncLocalStorage: optional(ASYNC_LOCAL_STORAGE_TOKEN),
         },
     }),
     provide({

package/lib/server/providers.js

@@ -17,8 +17,10 @@ var render = require('./render.js');
 var renderSlots = require('./render-slots.js');
 var constants = require('../shared/constants.js');
 var contractManager_server = require('../contracts/contractManager.server.js');
+var cache = require('./cache/cache.js');
 
 const serverProviders = [
+    ...cache.cache,
     core.provide({
         provide: tokensCommon.ENV_USED_TOKEN,
         multi: true,
@@ -41,10 +43,8 @@ const serverProviders = [
             },
             hookFactory: core.TAPABLE_HOOK_FACTORY_TOKEN,
             logger: tokensCommon.LOGGER_TOKEN,
-            createCache: tokensCommon.CREATE_CACHE_TOKEN,
-            cacheOptions: dippy.optional(tokensChildApp.CHILD_APP_LOADER_CACHE_OPTIONS_TOKEN),
+            cache: tokensChildApp.CHILD_APP_LOADER_CACHE_TOKEN,
             envManager: tokensCommon.ENV_MANAGER_TOKEN,
-            asyncLocalStorage: dippy.optional(tokensCommon.ASYNC_LOCAL_STORAGE_TOKEN),
         },
     }),
     core.provide({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-child-app",
-  "version": "5.53.80",
+  "version": "6.62.0",
   "description": "Module for child apps",
   "browser": {
     "./lib/server.es.js": "./lib/browser.js",
@@ -30,26 +30,26 @@
   },
   "dependencies": {
     "@loadable/server": "^5.15.0",
-    "@tinkoff/env-validators": "0.4.3",
-    "@tinkoff/errors": "0.6.4",
-    "@tinkoff/module-loader-client": "0.7.6",
-    "@tinkoff/module-loader-server": "0.8.9",
-    "@tinkoff/url": "0.11.4",
-    "@tramvai/child-app-core": "5.53.80",
-    "@tramvai/module-common": "5.53.80",
-    "@tramvai/safe-strings": "0.8.5",
-    "@tramvai/tokens-child-app": "5.53.80"
+    "@tinkoff/env-validators": "0.5.0",
+    "@tinkoff/errors": "0.7.1",
+    "@tinkoff/module-loader-client": "0.8.1",
+    "@tinkoff/module-loader-server": "0.9.1",
+    "@tinkoff/url": "0.12.1",
+    "@tramvai/child-app-core": "6.62.0",
+    "@tramvai/module-common": "6.62.0",
+    "@tramvai/safe-strings": "0.9.0",
+    "@tramvai/tokens-child-app": "6.62.0"
   },
   "peerDependencies": {
-    "@tinkoff/dippy": "0.11.6",
-    "@tinkoff/router": "0.5.204",
+    "@tinkoff/dippy": "0.12.3",
+    "@tinkoff/router": "0.6.105",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/core": "5.53.80",
-    "@tramvai/react": "5.53.80",
-    "@tramvai/state": "5.53.80",
-    "@tramvai/tokens-common": "5.53.80",
-    "@tramvai/tokens-render": "5.53.80",
-    "@tramvai/tokens-router": "5.53.80",
+    "@tramvai/core": "6.62.0",
+    "@tramvai/react": "6.62.0",
+    "@tramvai/state": "6.62.0",
+    "@tramvai/tokens-common": "6.62.0",
+    "@tramvai/tokens-render": "6.62.0",
+    "@tramvai/tokens-router": "6.62.0",
     "object-assign": "^4.1.1",
     "react": ">=16.14.0",
     "react-dom": ">=16.14.0",