@tramvai/module-server 2.72.4 → 2.73.0

package/README.md

@@ -186,6 +186,31 @@ To see values that related to request look for the header `Server-Timing` or che
 
 Module uses loggers with identifiers: `server`, `server:static`, `server:webapp`, `server:node-debug:request`
 
+### Early Hints
+
+Module send the [103 Early Hints](https://developer.chrome.com/blog/early-hints) response to provide better performance, though there are several limitations (look [here](https://chromium.googlesource.com/chromium/src/+/master/docs/early-hints.md#what_s-not-supported) and [here](https://developer.chrome.com/blog/early-hints/#current-limitations)). Currently, module provides hints for next resources:
+
+- Resources with `preconnectLink` type;
+- General resources, which have the `preloadLink` type;
+- Page resources, that exist in the `ResourcesRegistry` with `'data-critical': "true"` attribute;
+- Preconnects for CDN urls, that are computed from `preloadLink` or `data-critical` resources, described above;
+
+Server will try to response with 103 as soon as possible and there can be more than one such responses.
+
+```shell
+curl -I -X HEAD http://localhost:3000
+
+HTTP/1.1 103 Early Hints
+Link: <https://www.cdn-tinkoff.ru>; rel=preconnect
+Link: <https://www.cdn-tinkoff.ru/frontend-libraries/npm/react-kit-font/1.0.0/TinkoffSans.woff2>; rel=preload; as=font
+Link: <https://www-stage.cdn-tinkoff.ru/frontend-libraries/feedback/1.14.0/feedback.css>; rel=preload; as=style
+Link: <https://www-stage.cdn-tinkoff.ru>; rel=preconnect
+
+HTTP/1.1 200 OK
+...
+
+```
+
 ## How to
 
 ### Setting `keepAliveTimeout` for the server

package/lib/modules/earlyHints/index.d.ts

@@ -0,0 +1,2 @@
+export declare class EarlyHintsModule {
+}

package/lib/modules/earlyHints/index.es.js

@@ -0,0 +1,84 @@
+import { __decorate } from 'tslib';
+import { Module, provide, commandLineListTokens } from '@tramvai/core';
+import { EARLY_HINTS_MANAGER_TOKEN, FASTIFY_RESPONSE } from '@tramvai/tokens-server-private';
+import { RESOURCES_REGISTRY, RENDER_FLOW_AFTER_TOKEN } from '@tramvai/tokens-render';
+import { EarlyHintsManager } from './service.es.js';
+
+let EarlyHintsModule = class EarlyHintsModule {
+};
+EarlyHintsModule = __decorate([
+    Module({
+        providers: [
+            provide({
+                provide: EARLY_HINTS_MANAGER_TOKEN,
+                useClass: EarlyHintsManager,
+                deps: {
+                    response: FASTIFY_RESPONSE,
+                    resourcesRegistry: RESOURCES_REGISTRY,
+                },
+            }),
+            provide({
+                provide: commandLineListTokens.customerStart,
+                multi: true,
+                useFactory: ({ earlyHints }) => {
+                    return async function writeCommonEarlyHints() {
+                        await earlyHints.flushHints();
+                    };
+                },
+                deps: {
+                    earlyHints: EARLY_HINTS_MANAGER_TOKEN,
+                },
+            }),
+            provide({
+                provide: commandLineListTokens.resolvePageDeps,
+                multi: true,
+                useFactory: ({ earlyHints }) => {
+                    return async function writeCommonEarlyHints() {
+                        await earlyHints.flushHints();
+                    };
+                },
+                deps: {
+                    earlyHints: EARLY_HINTS_MANAGER_TOKEN,
+                },
+            }),
+            provide({
+                provide: commandLineListTokens.resolveUserDeps,
+                multi: true,
+                useFactory: ({ earlyHints }) => {
+                    return async function writeCommonEarlyHints() {
+                        await earlyHints.flushHints();
+                    };
+                },
+                deps: {
+                    earlyHints: EARLY_HINTS_MANAGER_TOKEN,
+                },
+            }),
+            provide({
+                provide: commandLineListTokens.generatePage,
+                multi: true,
+                useFactory: ({ earlyHints }) => {
+                    return async function writeCommonEarlyHints() {
+                        await earlyHints.flushHints();
+                    };
+                },
+                deps: {
+                    earlyHints: EARLY_HINTS_MANAGER_TOKEN,
+                },
+            }),
+            provide({
+                provide: RENDER_FLOW_AFTER_TOKEN,
+                multi: true,
+                useFactory: ({ earlyHints }) => {
+                    return async function writePageEarlyHints() {
+                        await earlyHints.flushHints();
+                    };
+                },
+                deps: {
+                    earlyHints: EARLY_HINTS_MANAGER_TOKEN,
+                },
+            }),
+        ],
+    })
+], EarlyHintsModule);
+
+export { EarlyHintsModule };

package/lib/modules/earlyHints/index.js

@@ -0,0 +1,86 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var core = require('@tramvai/core');
+var tokensServerPrivate = require('@tramvai/tokens-server-private');
+var tokensRender = require('@tramvai/tokens-render');
+var service = require('./service.js');
+
+exports.EarlyHintsModule = class EarlyHintsModule {
+};
+exports.EarlyHintsModule = tslib.__decorate([
+    core.Module({
+        providers: [
+            core.provide({
+                provide: tokensServerPrivate.EARLY_HINTS_MANAGER_TOKEN,
+                useClass: service.EarlyHintsManager,
+                deps: {
+                    response: tokensServerPrivate.FASTIFY_RESPONSE,
+                    resourcesRegistry: tokensRender.RESOURCES_REGISTRY,
+                },
+            }),
+            core.provide({
+                provide: core.commandLineListTokens.customerStart,
+                multi: true,
+                useFactory: ({ earlyHints }) => {
+                    return async function writeCommonEarlyHints() {
+                        await earlyHints.flushHints();
+                    };
+                },
+                deps: {
+                    earlyHints: tokensServerPrivate.EARLY_HINTS_MANAGER_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: core.commandLineListTokens.resolvePageDeps,
+                multi: true,
+                useFactory: ({ earlyHints }) => {
+                    return async function writeCommonEarlyHints() {
+                        await earlyHints.flushHints();
+                    };
+                },
+                deps: {
+                    earlyHints: tokensServerPrivate.EARLY_HINTS_MANAGER_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: core.commandLineListTokens.resolveUserDeps,
+                multi: true,
+                useFactory: ({ earlyHints }) => {
+                    return async function writeCommonEarlyHints() {
+                        await earlyHints.flushHints();
+                    };
+                },
+                deps: {
+                    earlyHints: tokensServerPrivate.EARLY_HINTS_MANAGER_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: core.commandLineListTokens.generatePage,
+                multi: true,
+                useFactory: ({ earlyHints }) => {
+                    return async function writeCommonEarlyHints() {
+                        await earlyHints.flushHints();
+                    };
+                },
+                deps: {
+                    earlyHints: tokensServerPrivate.EARLY_HINTS_MANAGER_TOKEN,
+                },
+            }),
+            core.provide({
+                provide: tokensRender.RENDER_FLOW_AFTER_TOKEN,
+                multi: true,
+                useFactory: ({ earlyHints }) => {
+                    return async function writePageEarlyHints() {
+                        await earlyHints.flushHints();
+                    };
+                },
+                deps: {
+                    earlyHints: tokensServerPrivate.EARLY_HINTS_MANAGER_TOKEN,
+                },
+            }),
+        ],
+    })
+], exports.EarlyHintsModule);

package/lib/modules/earlyHints/service.d.ts

@@ -0,0 +1,23 @@
+import type { FASTIFY_RESPONSE, EARLY_HINTS_MANAGER_TOKEN } from '@tramvai/tokens-server-private';
+import type { RESOURCES_REGISTRY } from '@tramvai/tokens-render';
+type EarlyHintsInterface = typeof EARLY_HINTS_MANAGER_TOKEN;
+type Response = typeof FASTIFY_RESPONSE;
+type ResourcesRegistry = typeof RESOURCES_REGISTRY;
+interface ConstructorPayload {
+    response: Response;
+    resourcesRegistry: ResourcesRegistry;
+}
+export declare class EarlyHintsManager implements EarlyHintsInterface {
+    private sentHints;
+    private readonly response;
+    private readonly resourcesRegistry;
+    constructor(payload: ConstructorPayload);
+    flushHints(): Promise<void>;
+    private getHints;
+    private writeToSocket;
+    private getHttpMessage;
+    private getAsAttribute;
+    private getCdnHintForResource;
+    private doesHintUniq;
+}
+export {};

package/lib/modules/earlyHints/service.es.js

@@ -0,0 +1,78 @@
+class EarlyHintsManager {
+    constructor(payload) {
+        this.sentHints = new Set();
+        this.response = payload.response;
+        this.resourcesRegistry = payload.resourcesRegistry;
+    }
+    async flushHints() {
+        const hints = this.getHints();
+        await this.writeToSocket(hints);
+    }
+    getHints() {
+        return this.resourcesRegistry.getPageResources().reduce((acc, resource) => {
+            var _a, _b;
+            let resourceHint = null;
+            let cdnHint = null;
+            if (resource.type === 'preconnectLink') {
+                resourceHint = `Link: <${resource.payload}>; rel=preconnect`;
+            }
+            if (resource.type === 'preloadLink') {
+                const as = this.getAsAttribute(resource);
+                resourceHint = `Link: <${resource.payload}>; rel=preload;${as}`;
+                cdnHint = this.getCdnHintForResource(resource);
+            }
+            if (resource.type === 'style' && ((_a = resource.attrs) === null || _a === void 0 ? void 0 : _a['data-critical']) === 'true') {
+                resourceHint = `Link: <${resource.payload}>; rel=preload; as=style`;
+                cdnHint = this.getCdnHintForResource(resource);
+            }
+            // prevent scripts preloading because of potential large numbers of JS chunks for every page
+            // still check JS chunks for preconnects
+            if (resource.type === 'script' && ((_b = resource.attrs) === null || _b === void 0 ? void 0 : _b['data-critical']) === 'true') {
+                cdnHint = this.getCdnHintForResource(resource);
+            }
+            if (this.doesHintUniq(cdnHint)) {
+                acc.push(cdnHint);
+                this.sentHints.add(cdnHint);
+            }
+            if (this.doesHintUniq(resourceHint)) {
+                acc.push(resourceHint);
+                this.sentHints.add(resourceHint);
+            }
+            return acc;
+        }, []);
+    }
+    writeToSocket(hints) {
+        return new Promise((resolve) => {
+            const { socket } = this.response.raw;
+            // Socket will be null if the connection has been closed already
+            if (socket === null || hints.length === 0) {
+                resolve();
+                return;
+            }
+            const message = this.getHttpMessage(hints);
+            socket.write(message, 'ascii', () => {
+                resolve();
+            });
+        });
+    }
+    getHttpMessage(payload) {
+        const endOfLine = '\r\n';
+        const result = ['HTTP/1.1 103 Early Hints', ...payload];
+        // There must be an empty line between HTTP messages.
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Messages
+        return `${result.join(endOfLine)}${endOfLine.repeat(2)}`;
+    }
+    getAsAttribute(resource) {
+        var _a;
+        return ((_a = resource.attrs) === null || _a === void 0 ? void 0 : _a.as) !== undefined ? ` as=${resource.attrs.as}` : '';
+    }
+    getCdnHintForResource(resource) {
+        const match = resource.payload.match(/https:\/\/[^/'"]+/gi);
+        return match === null ? null : `Link: <${match[0]}>; rel=preconnect`;
+    }
+    doesHintUniq(hint) {
+        return hint !== null && !this.sentHints.has(hint);
+    }
+}
+
+export { EarlyHintsManager };

package/lib/modules/earlyHints/service.js

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class EarlyHintsManager {
+    constructor(payload) {
+        this.sentHints = new Set();
+        this.response = payload.response;
+        this.resourcesRegistry = payload.resourcesRegistry;
+    }
+    async flushHints() {
+        const hints = this.getHints();
+        await this.writeToSocket(hints);
+    }
+    getHints() {
+        return this.resourcesRegistry.getPageResources().reduce((acc, resource) => {
+            var _a, _b;
+            let resourceHint = null;
+            let cdnHint = null;
+            if (resource.type === 'preconnectLink') {
+                resourceHint = `Link: <${resource.payload}>; rel=preconnect`;
+            }
+            if (resource.type === 'preloadLink') {
+                const as = this.getAsAttribute(resource);
+                resourceHint = `Link: <${resource.payload}>; rel=preload;${as}`;
+                cdnHint = this.getCdnHintForResource(resource);
+            }
+            if (resource.type === 'style' && ((_a = resource.attrs) === null || _a === void 0 ? void 0 : _a['data-critical']) === 'true') {
+                resourceHint = `Link: <${resource.payload}>; rel=preload; as=style`;
+                cdnHint = this.getCdnHintForResource(resource);
+            }
+            // prevent scripts preloading because of potential large numbers of JS chunks for every page
+            // still check JS chunks for preconnects
+            if (resource.type === 'script' && ((_b = resource.attrs) === null || _b === void 0 ? void 0 : _b['data-critical']) === 'true') {
+                cdnHint = this.getCdnHintForResource(resource);
+            }
+            if (this.doesHintUniq(cdnHint)) {
+                acc.push(cdnHint);
+                this.sentHints.add(cdnHint);
+            }
+            if (this.doesHintUniq(resourceHint)) {
+                acc.push(resourceHint);
+                this.sentHints.add(resourceHint);
+            }
+            return acc;
+        }, []);
+    }
+    writeToSocket(hints) {
+        return new Promise((resolve) => {
+            const { socket } = this.response.raw;
+            // Socket will be null if the connection has been closed already
+            if (socket === null || hints.length === 0) {
+                resolve();
+                return;
+            }
+            const message = this.getHttpMessage(hints);
+            socket.write(message, 'ascii', () => {
+                resolve();
+            });
+        });
+    }
+    getHttpMessage(payload) {
+        const endOfLine = '\r\n';
+        const result = ['HTTP/1.1 103 Early Hints', ...payload];
+        // There must be an empty line between HTTP messages.
+        // https://developer.mozilla.org/en-US/docs/Web/HTTP/Messages
+        return `${result.join(endOfLine)}${endOfLine.repeat(2)}`;
+    }
+    getAsAttribute(resource) {
+        var _a;
+        return ((_a = resource.attrs) === null || _a === void 0 ? void 0 : _a.as) !== undefined ? ` as=${resource.attrs.as}` : '';
+    }
+    getCdnHintForResource(resource) {
+        const match = resource.payload.match(/https:\/\/[^/'"]+/gi);
+        return match === null ? null : `Link: <${match[0]}>; rel=preconnect`;
+    }
+    doesHintUniq(hint) {
+        return hint !== null && !this.sentHints.has(hint);
+    }
+}
+
+exports.EarlyHintsManager = EarlyHintsManager;

package/lib/modules/index.d.ts

@@ -7,3 +7,4 @@ export * from './dependenciesVersion';
 export * from './utilityServer';
 export * from './keepAlive';
 export * from './serverTiming';
+export * from './earlyHints';

package/lib/server.es.js

@@ -22,6 +22,7 @@ import { DependenciesVersionModule } from './modules/dependenciesVersion.es.js';
 import { UtilityServerModule } from './modules/utilityServer.es.js';
 import { KeepAliveModule } from './modules/keepAlive.es.js';
 import { ServerTimingModule } from './modules/serverTiming.es.js';
+import { EarlyHintsModule } from './modules/earlyHints/index.es.js';
 
 if (typeof setDefaultResultOrder === 'function') {
     setDefaultResultOrder('ipv4first');
@@ -44,6 +45,7 @@ ServerModule = __decorate([
             UtilityServerModule,
             KeepAliveModule,
             ServerTimingModule,
+            EarlyHintsModule,
             process.env.NODE_ENV !== 'production' && DebugHttpRequestsModule,
         ].filter(Boolean),
         providers: [

package/lib/server.js

@@ -25,6 +25,7 @@ var dependenciesVersion = require('./modules/dependenciesVersion.js');
 var utilityServer = require('./modules/utilityServer.js');
 var keepAlive = require('./modules/keepAlive.js');
 var serverTiming = require('./modules/serverTiming.js');
+var index = require('./modules/earlyHints/index.js');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -51,6 +52,7 @@ exports.ServerModule = tslib.__decorate([
             utilityServer.UtilityServerModule,
             keepAlive.KeepAliveModule,
             serverTiming.ServerTimingModule,
+            index.EarlyHintsModule,
             process.env.NODE_ENV !== 'production' && debugRequests.DebugHttpRequestsModule,
         ].filter(Boolean),
         providers: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tramvai/module-server",
-  "version": "2.72.4",
+  "version": "2.73.0",
   "description": "",
   "browser": "lib/browser.js",
   "main": "lib/server.js",
@@ -25,11 +25,11 @@
     "@tinkoff/monkeypatch": "2.0.4",
     "@tinkoff/terminus": "0.1.7",
     "@tinkoff/url": "0.8.5",
-    "@tramvai/module-cache-warmup": "2.72.4",
-    "@tramvai/module-metrics": "2.72.4",
-    "@tramvai/papi": "2.72.4",
-    "@tramvai/tokens-server": "2.72.4",
-    "@tramvai/tokens-server-private": "2.72.4",
+    "@tramvai/module-cache-warmup": "2.73.0",
+    "@tramvai/module-metrics": "2.73.0",
+    "@tramvai/papi": "2.73.0",
+    "@tramvai/tokens-server": "2.73.0",
+    "@tramvai/tokens-server-private": "2.73.0",
     "fastify": "^4.6.0",
     "@fastify/cookie": "^8.1.0",
     "@fastify/compress": "^6.1.1",
@@ -40,12 +40,13 @@
   "peerDependencies": {
     "@tinkoff/dippy": "0.8.13",
     "@tinkoff/utils": "^2.1.2",
-    "@tramvai/cli": "2.72.4",
-    "@tramvai/core": "2.72.4",
-    "@tramvai/module-common": "2.72.4",
-    "@tramvai/module-environment": "2.72.4",
-    "@tramvai/tokens-common": "2.72.4",
-    "@tramvai/tokens-core-private": "2.72.4",
+    "@tramvai/cli": "2.73.0",
+    "@tramvai/core": "2.73.0",
+    "@tramvai/module-common": "2.73.0",
+    "@tramvai/module-environment": "2.73.0",
+    "@tramvai/tokens-common": "2.73.0",
+    "@tramvai/tokens-core-private": "2.73.0",
+    "@tramvai/tokens-render": "2.73.0",
     "tslib": "^2.4.0"
   },
   "devDependencies": {