@tramvai/module-cache-warmup 6.68.6 → 6.77.2

package/README.md

@@ -19,8 +19,42 @@ createApp({
 
 > Module is executed only when `NODE_ENV === production`.
 
-1. When app starts the module will request list of app urls from papi-route `bundleInfo`.
-2. For every url from the response it sends `2` requests: one for mobile and one for desktop device. But only `2` requests are running simultaneously in total.
+1. When app starts the module will request list of app urls from papi-route `prerenderRoutes`.
+2. For every url from the response it sends two requests: one for mobile and one for desktop device. But only `1` requests are running simultaneously in total.
+3. Routes with dynamic parameters, like `/blog/:id/`, will be skipped by default
+
+### Routes with dynamic parameters
+
+For example, you want to warmp up dynamic routes like `/blog/1/`, `/blog/2/` and `/blog/3/`. CacheWarmupModule will use the same urls list as `tramvai static` command, so you need to use the same mechanism - [custom `prerender:routes` hook](03-features/010-rendering/04-ssg.md#routes-with-dynamic-parameters).
+
+### Filtering routes from warmup
+
+If you want to exclude some routes from warmup, you can use `cache-warmup:request` hook for `CACHE_WARMUP_HOOKS_TOKEN` token:
+
+```ts
+const provider = provide({
+  provide: commandLineListTokens.listen,
+  useFactory: ({ hooks, logger }) => {
+    return async function filterWarmupRoutes() {
+      hooks['cache-warmup:request'].wrap(async (_, payload, next) => {
+        // Match request url or any other parameters, and skip it
+        if (payload.parameters.url?.includes('/some-unpopular-and-heavy-page')) {
+          return {
+            parameters: payload.parameters,
+            result: 'skipped',
+          };
+        }
+        // Otherwise, continue with the request
+        return next(payload);
+      });
+    };
+  },
+  deps: {
+    hooks: CACHE_WARMUP_HOOKS_TOKEN,
+    logger: LOGGER_TOKEN,
+  },
+});
+```
 
 ### User-agent
 

package/lib/browser.d.ts

@@ -1,3 +1,4 @@
+export * from './tokens';
 export declare class CacheWarmupModule {
 }
 //# sourceMappingURL=browser.d.ts.map

package/lib/browser.js

@@ -1,5 +1,6 @@
 import { __decorate } from 'tslib';
 import { Module } from '@tramvai/core';
+export { CACHE_WARMUP_ENABLED_TOKEN, CACHE_WARMUP_HOOKS_TOKEN } from './tokens.browser.js';
 
 let CacheWarmupModule = class CacheWarmupModule {
 };

package/lib/server.d.ts

@@ -1,3 +1,4 @@
+export * from './tokens';
 export declare class CacheWarmupModule {
 }
 //# sourceMappingURL=server.d.ts.map

package/lib/server.es.js

@@ -1,8 +1,10 @@
 import { __decorate } from 'tslib';
-import { Module, provide, commandLineListTokens } from '@tramvai/core';
+import { Module, provide, commandLineListTokens, TAPABLE_HOOK_FACTORY_TOKEN } from '@tramvai/core';
 import { PAPI_SERVICE } from '@tramvai/tokens-http-client';
 import { LOGGER_TOKEN, ENV_MANAGER_TOKEN } from '@tramvai/module-common';
 import { warmUpCache } from './warmup.es.js';
+import { CACHE_WARMUP_ENABLED_TOKEN, CACHE_WARMUP_HOOKS_TOKEN } from './tokens.es.js';
+export { CACHE_WARMUP_ENABLED_TOKEN, CACHE_WARMUP_HOOKS_TOKEN } from './tokens.es.js';
 
 let CacheWarmupModule = class CacheWarmupModule {
 };
@@ -10,35 +12,77 @@ CacheWarmupModule = __decorate([
     Module({
         imports: [],
         providers: [
+            provide({
+                provide: CACHE_WARMUP_ENABLED_TOKEN,
+                useFactory: ({ papiService, logger }) => {
+                    const log = logger('cache-warmup');
+                    if (!papiService) {
+                        log.info('Skip cache warmup when @tramvai/module-http-client is not enabled');
+                        return false;
+                    }
+                    if (process.env.CACHE_WARMUP_DISABLED === 'true') {
+                        log.info('Skip cache warm up due to CACHE_WARMUP_DISABLED env');
+                        return false;
+                    }
+                    if (process.env.NODE_ENV !== 'production') {
+                        log.info('Skip cache warm up in dev environment');
+                        return false;
+                    }
+                    // TODO: revisit this condition
+                    // if (process.env.MOCKER_ENABLED === 'true') {
+                    //   log.info('Skip cache warm up when mocker is enabled');
+                    //   return false;
+                    // }
+                    return true;
+                },
+                deps: {
+                    papiService: { token: PAPI_SERVICE, optional: true },
+                    logger: LOGGER_TOKEN,
+                },
+            }),
             provide({
                 provide: commandLineListTokens.listen,
                 multi: true,
-                useFactory({ papiService, logger, environmentManager }) {
-                    return () => {
-                        const log = logger('cache-warmup');
-                        if (!papiService) {
-                            log.info('Skip cache warmup when @tramvai/module-http-client is not enabled');
+                useFactory({ papiService, logger, environmentManager, hooks, cacheWarmupEnabled }) {
+                    return function cacheWarmup() {
+                        if (!cacheWarmupEnabled) {
                             return;
                         }
-                        if (process.env.CACHE_WARMUP_DISABLED === 'true') {
-                            log.info('Skip cache warm up due to CACHE_WARMUP_DISABLED env');
-                            return;
-                        }
-                        if (process.env.NODE_ENV !== 'production') {
-                            log.info('Skip cache warm up in dev environment');
-                            return;
-                        }
-                        if (process.env.MOCKER_ENABLED === 'true') {
-                            log.info('Skip cache warm up when mocker is enabled');
-                            return;
-                        }
-                        warmUpCache({ papiService, logger, environmentManager });
+                        hooks['cache-warmup:request'].tapPromise('CacheWarmupPlugin', async (_, { request, parameters }) => {
+                            try {
+                                await request(parameters);
+                                return {
+                                    parameters,
+                                    result: 'resolved',
+                                };
+                            }
+                            catch {
+                                return {
+                                    parameters,
+                                    result: 'rejected',
+                                };
+                            }
+                        });
+                        warmUpCache({ papiService: papiService, logger, environmentManager, hooks });
                     };
                 },
                 deps: {
                     papiService: { token: PAPI_SERVICE, optional: true },
                     logger: LOGGER_TOKEN,
                     environmentManager: ENV_MANAGER_TOKEN,
+                    hooks: CACHE_WARMUP_HOOKS_TOKEN,
+                    cacheWarmupEnabled: CACHE_WARMUP_ENABLED_TOKEN,
+                },
+            }),
+            provide({
+                provide: CACHE_WARMUP_HOOKS_TOKEN,
+                useFactory: ({ hooksFactory }) => {
+                    return {
+                        'cache-warmup:request': hooksFactory.createAsync('cache-warmup:request'),
+                    };
+                },
+                deps: {
+                    hooksFactory: TAPABLE_HOOK_FACTORY_TOKEN,
                 },
             }),
         ],

package/lib/server.js

@@ -7,6 +7,7 @@ var core = require('@tramvai/core');
 var tokensHttpClient = require('@tramvai/tokens-http-client');
 var moduleCommon = require('@tramvai/module-common');
 var warmup = require('./warmup.js');
+var tokens = require('./tokens.js');
 
 exports.CacheWarmupModule = class CacheWarmupModule {
 };
@@ -14,37 +15,82 @@ exports.CacheWarmupModule = tslib.__decorate([
     core.Module({
         imports: [],
         providers: [
+            core.provide({
+                provide: tokens.CACHE_WARMUP_ENABLED_TOKEN,
+                useFactory: ({ papiService, logger }) => {
+                    const log = logger('cache-warmup');
+                    if (!papiService) {
+                        log.info('Skip cache warmup when @tramvai/module-http-client is not enabled');
+                        return false;
+                    }
+                    if (process.env.CACHE_WARMUP_DISABLED === 'true') {
+                        log.info('Skip cache warm up due to CACHE_WARMUP_DISABLED env');
+                        return false;
+                    }
+                    if (process.env.NODE_ENV !== 'production') {
+                        log.info('Skip cache warm up in dev environment');
+                        return false;
+                    }
+                    // TODO: revisit this condition
+                    // if (process.env.MOCKER_ENABLED === 'true') {
+                    //   log.info('Skip cache warm up when mocker is enabled');
+                    //   return false;
+                    // }
+                    return true;
+                },
+                deps: {
+                    papiService: { token: tokensHttpClient.PAPI_SERVICE, optional: true },
+                    logger: moduleCommon.LOGGER_TOKEN,
+                },
+            }),
             core.provide({
                 provide: core.commandLineListTokens.listen,
                 multi: true,
-                useFactory({ papiService, logger, environmentManager }) {
-                    return () => {
-                        const log = logger('cache-warmup');
-                        if (!papiService) {
-                            log.info('Skip cache warmup when @tramvai/module-http-client is not enabled');
-                            return;
-                        }
-                        if (process.env.CACHE_WARMUP_DISABLED === 'true') {
-                            log.info('Skip cache warm up due to CACHE_WARMUP_DISABLED env');
-                            return;
-                        }
-                        if (process.env.NODE_ENV !== 'production') {
-                            log.info('Skip cache warm up in dev environment');
-                            return;
-                        }
-                        if (process.env.MOCKER_ENABLED === 'true') {
-                            log.info('Skip cache warm up when mocker is enabled');
+                useFactory({ papiService, logger, environmentManager, hooks, cacheWarmupEnabled }) {
+                    return function cacheWarmup() {
+                        if (!cacheWarmupEnabled) {
                             return;
                         }
-                        warmup.warmUpCache({ papiService, logger, environmentManager });
+                        hooks['cache-warmup:request'].tapPromise('CacheWarmupPlugin', async (_, { request, parameters }) => {
+                            try {
+                                await request(parameters);
+                                return {
+                                    parameters,
+                                    result: 'resolved',
+                                };
+                            }
+                            catch {
+                                return {
+                                    parameters,
+                                    result: 'rejected',
+                                };
+                            }
+                        });
+                        warmup.warmUpCache({ papiService: papiService, logger, environmentManager, hooks });
                     };
                 },
                 deps: {
                     papiService: { token: tokensHttpClient.PAPI_SERVICE, optional: true },
                     logger: moduleCommon.LOGGER_TOKEN,
                     environmentManager: moduleCommon.ENV_MANAGER_TOKEN,
+                    hooks: tokens.CACHE_WARMUP_HOOKS_TOKEN,
+                    cacheWarmupEnabled: tokens.CACHE_WARMUP_ENABLED_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: tokens.CACHE_WARMUP_HOOKS_TOKEN,
+                useFactory: ({ hooksFactory }) => {
+                    return {
+                        'cache-warmup:request': hooksFactory.createAsync('cache-warmup:request'),
+                    };
+                },
+                deps: {
+                    hooksFactory: core.TAPABLE_HOOK_FACTORY_TOKEN,
                 },
             }),
         ],
     })
 ], exports.CacheWarmupModule);
+
+exports.CACHE_WARMUP_ENABLED_TOKEN = tokens.CACHE_WARMUP_ENABLED_TOKEN;
+exports.CACHE_WARMUP_HOOKS_TOKEN = tokens.CACHE_WARMUP_HOOKS_TOKEN;

package/lib/tokens.browser.js

@@ -0,0 +1,8 @@
+import { createToken, Scope } from '@tramvai/core';
+
+const CACHE_WARMUP_ENABLED_TOKEN = createToken('tramvai cache warmup enabled', {
+    scope: Scope.SINGLETON,
+});
+const CACHE_WARMUP_HOOKS_TOKEN = createToken('tramvai cache warmup hooks', { scope: Scope.SINGLETON });
+
+export { CACHE_WARMUP_ENABLED_TOKEN, CACHE_WARMUP_HOOKS_TOKEN };

package/lib/tokens.d.ts

@@ -0,0 +1,20 @@
+import { AsyncTapableHookInstance } from '@tramvai/core';
+import type { Request } from '@tinkoff/request-core';
+export declare const CACHE_WARMUP_ENABLED_TOKEN: (false & {
+    __type?: "base token" | undefined;
+}) | (true & {
+    __type?: "base token" | undefined;
+});
+export type CacheWarmupHooks = {
+    'cache-warmup:request': AsyncTapableHookInstance<{
+        request: (parameters: Request) => Promise<unknown>;
+        parameters: Request;
+    }, {
+        parameters: Request;
+        result: 'resolved' | 'rejected' | 'skipped';
+    }>;
+};
+export declare const CACHE_WARMUP_HOOKS_TOKEN: CacheWarmupHooks & {
+    __type?: "base token" | undefined;
+};
+//# sourceMappingURL=tokens.d.ts.map

package/lib/tokens.es.js

@@ -0,0 +1,8 @@
+import { createToken, Scope } from '@tramvai/core';
+
+const CACHE_WARMUP_ENABLED_TOKEN = createToken('tramvai cache warmup enabled', {
+    scope: Scope.SINGLETON,
+});
+const CACHE_WARMUP_HOOKS_TOKEN = createToken('tramvai cache warmup hooks', { scope: Scope.SINGLETON });
+
+export { CACHE_WARMUP_ENABLED_TOKEN, CACHE_WARMUP_HOOKS_TOKEN };

package/lib/tokens.js

@@ -0,0 +1,13 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var core = require('@tramvai/core');
+
+const CACHE_WARMUP_ENABLED_TOKEN = core.createToken('tramvai cache warmup enabled', {
+    scope: core.Scope.SINGLETON,
+});
+const CACHE_WARMUP_HOOKS_TOKEN = core.createToken('tramvai cache warmup hooks', { scope: core.Scope.SINGLETON });
+
+exports.CACHE_WARMUP_ENABLED_TOKEN = CACHE_WARMUP_ENABLED_TOKEN;
+exports.CACHE_WARMUP_HOOKS_TOKEN = CACHE_WARMUP_HOOKS_TOKEN;

package/lib/utils.d.ts

@@ -1,4 +1,6 @@
 import type { Request } from '@tinkoff/request-core';
+import { ExtractDependencyType } from '@tramvai/core';
+import { CACHE_WARMUP_HOOKS_TOKEN } from './tokens';
 type QueueReuestsOptions<T> = {
     requestsOptions: T[];
     makeRequest: (requestOptions: T) => Promise<unknown>;
@@ -7,10 +9,11 @@ type QueueReuestsOptions<T> = {
      * @default 2
      */
     maxSimultaneous?: number;
+    hooks: ExtractDependencyType<typeof CACHE_WARMUP_HOOKS_TOKEN>;
 };
 export declare function queueRequests<T>(options: QueueReuestsOptions<T>): Promise<{
-    option: T;
-    result: string;
+    parameters: Request;
+    result: "resolved" | "rejected" | "skipped";
 }[]>;
 export declare function createRequestsOptions(options: {
     urls: string[];

package/lib/utils.es.js

@@ -6,19 +6,11 @@ const request = requestFactory([httpPlugin()]);
 async function queueRequests(options) {
     const { maxSimultaneous = 2, makeRequest, requestsOptions } = options;
     const req = async (option) => {
-        try {
-            await makeRequest(option);
-            return {
-                option,
-                result: 'resolved',
-            };
-        }
-        catch {
-            return {
-                option,
-                result: 'rejected',
-            };
-        }
+        const result = await options.hooks['cache-warmup:request'].callPromise({
+            request: makeRequest,
+            parameters: option,
+        });
+        return result;
     };
     const queue = [];
     const result = [];
@@ -45,7 +37,7 @@ function createRequestsOptions(options) {
             url: format({
                 hostname: 'localhost',
                 port,
-                path: url.replace(/:\w+/g, '0'),
+                path: url,
             }),
             headers: {
                 'User-Agent': userAgent,

package/lib/utils.js

@@ -15,19 +15,11 @@ const request = requestFactory__default["default"]([httpPlugin__default["default
 async function queueRequests(options) {
     const { maxSimultaneous = 2, makeRequest, requestsOptions } = options;
     const req = async (option) => {
-        try {
-            await makeRequest(option);
-            return {
-                option,
-                result: 'resolved',
-            };
-        }
-        catch {
-            return {
-                option,
-                result: 'rejected',
-            };
-        }
+        const result = await options.hooks['cache-warmup:request'].callPromise({
+            request: makeRequest,
+            parameters: option,
+        });
+        return result;
     };
     const queue = [];
     const result = [];
@@ -54,7 +46,7 @@ function createRequestsOptions(options) {
             url: url.format({
                 hostname: 'localhost',
                 port,
-                path: url$1.replace(/:\w+/g, '0'),
+                path: url$1,
             }),
             headers: {
                 'User-Agent': userAgent,

package/lib/warmup.d.ts

@@ -1,8 +1,12 @@
 import type { PAPI_SERVICE } from '@tramvai/tokens-http-client';
 import type { ENV_MANAGER_TOKEN, LOGGER_TOKEN } from '@tramvai/module-common';
+import { ExtractDependencyType } from '@tramvai/core';
+import { CACHE_WARMUP_HOOKS_TOKEN } from './tokens';
+export declare const deduplicateArray: <T>(list: T[]) => T[];
 export declare function warmUpCache(options: {
-    papiService: typeof PAPI_SERVICE;
-    logger: typeof LOGGER_TOKEN;
-    environmentManager: typeof ENV_MANAGER_TOKEN;
+    papiService: ExtractDependencyType<typeof PAPI_SERVICE>;
+    logger: ExtractDependencyType<typeof LOGGER_TOKEN>;
+    environmentManager: ExtractDependencyType<typeof ENV_MANAGER_TOKEN>;
+    hooks: ExtractDependencyType<typeof CACHE_WARMUP_HOOKS_TOKEN>;
 }): Promise<void>;
 //# sourceMappingURL=warmup.d.ts.map

package/lib/warmup.es.js

@@ -6,35 +6,46 @@ const userAgents = [
     /**  Chrome on Mobile */
     'Mozilla/5.0 (Linux; Android 12.0; Pixel 5 XL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3904.108 Mobile Safari/537.36',
 ];
+const deduplicateArray = (list) => {
+    return Array.from(new Set(list));
+};
 async function warmUpCache(options) {
-    const { papiService, logger, environmentManager } = options;
+    const { papiService, logger, environmentManager, hooks } = options;
     const log = logger('cache-warmup');
     const startTimestamp = Date.now();
     log.info("Cache warmup process 'START'");
     try {
         const { payload: urls } = await papiService.request({
-            path: 'bundleInfo',
+            path: 'prerenderRoutes',
         });
         const requestsOptions = createRequestsOptions({
             urls,
             port: environmentManager.get('PORT'),
             userAgents,
         });
+        log.info(`Cache warmup URLs:\n${deduplicateArray(requestsOptions.map((v) => v.url)).join('\n')}`);
         const results = await queueRequests({
             makeRequest: sendWarmUpRequest,
             requestsOptions,
             maxSimultaneous: 1,
+            hooks,
         });
         const failed = results.filter((result) => result.result === 'rejected');
+        const skipped = results.filter((result) => result.result === 'skipped');
         if (failed.length) {
             log.info(`Cache warmup process 'FINISHED' with errors, failed URLs:\n${failed
-                .map((v) => v.option.path)
+                .map((v) => v.parameters.url)
+                .join('\n')}`);
+        }
+        else if (skipped.length) {
+            log.info(`Cache warmup process 'SUCCESS', skipped URLs:\n${skipped
+                .map((v) => v.parameters.url)
                 .join('\n')}`);
         }
         else {
             log.info("Cache warmup process 'SUCCESS'");
         }
-        log.info(`Cache warmup  made ${results.length} requests for ${urls.length} URLs`);
+        log.info(`Cache warmup made ${results.length - skipped.length} requests for ${urls.length} URLs`);
         log.info(`Cache warmup took - ${Date.now() - startTimestamp}ms`);
     }
     catch (error) {
@@ -42,4 +53,4 @@ async function warmUpCache(options) {
     }
 }
 
-export { warmUpCache };
+export { deduplicateArray, warmUpCache };

package/lib/warmup.js

@@ -10,35 +10,46 @@ const userAgents = [
     /**  Chrome on Mobile */
     'Mozilla/5.0 (Linux; Android 12.0; Pixel 5 XL) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3904.108 Mobile Safari/537.36',
 ];
+const deduplicateArray = (list) => {
+    return Array.from(new Set(list));
+};
 async function warmUpCache(options) {
-    const { papiService, logger, environmentManager } = options;
+    const { papiService, logger, environmentManager, hooks } = options;
     const log = logger('cache-warmup');
     const startTimestamp = Date.now();
     log.info("Cache warmup process 'START'");
     try {
         const { payload: urls } = await papiService.request({
-            path: 'bundleInfo',
+            path: 'prerenderRoutes',
         });
         const requestsOptions = utils.createRequestsOptions({
             urls,
             port: environmentManager.get('PORT'),
             userAgents,
         });
+        log.info(`Cache warmup URLs:\n${deduplicateArray(requestsOptions.map((v) => v.url)).join('\n')}`);
         const results = await utils.queueRequests({
             makeRequest: utils.sendWarmUpRequest,
             requestsOptions,
             maxSimultaneous: 1,
+            hooks,
         });
         const failed = results.filter((result) => result.result === 'rejected');
+        const skipped = results.filter((result) => result.result === 'skipped');
         if (failed.length) {
             log.info(`Cache warmup process 'FINISHED' with errors, failed URLs:\n${failed
-                .map((v) => v.option.path)
+                .map((v) => v.parameters.url)
+                .join('\n')}`);
+        }
+        else if (skipped.length) {
+            log.info(`Cache warmup process 'SUCCESS', skipped URLs:\n${skipped
+                .map((v) => v.parameters.url)
                 .join('\n')}`);
         }
         else {
             log.info("Cache warmup process 'SUCCESS'");
         }
-        log.info(`Cache warmup  made ${results.length} requests for ${urls.length} URLs`);
+        log.info(`Cache warmup made ${results.length - skipped.length} requests for ${urls.length} URLs`);
         log.info(`Cache warmup took - ${Date.now() - startTimestamp}ms`);
     }
     catch (error) {
@@ -46,4 +57,5 @@ async function warmUpCache(options) {
     }
 }
 
+exports.deduplicateArray = deduplicateArray;
 exports.warmUpCache = warmUpCache;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-cache-warmup",
-  "version": "6.68.6",
+  "version": "6.77.2",
   "description": "tramvai cache warmup module",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
@@ -20,15 +20,15 @@
   },
   "dependencies": {
     "@tinkoff/request-core": "^0.10.0",
-    "@tinkoff/request-plugin-protocol-http": "0.15.0",
-    "@tinkoff/url": "0.12.1",
+    "@tinkoff/request-plugin-protocol-http": "0.16.0",
+    "@tinkoff/url": "0.12.2",
     "undici": "^7.16.0"
   },
   "peerDependencies": {
-    "@tramvai/core": "6.68.6",
-    "@tramvai/module-common": "6.68.6",
-    "@tramvai/state": "6.68.6",
-    "@tramvai/tokens-http-client": "6.68.6",
+    "@tramvai/core": "6.77.2",
+    "@tramvai/module-common": "6.77.2",
+    "@tramvai/state": "6.77.2",
+    "@tramvai/tokens-http-client": "6.77.2",
     "tslib": "^2.4.0"
   },
   "module": "lib/server.es.js",