@spartacus/setup
Version:
Includes features that makes Spartacus and it's setup easier and streamlined.
305 lines • 43.7 kB
JavaScript
import * as fs from 'fs';
import { getRequestUrl } from '../util/request-url';
import { RenderingCache } from './rendering-cache';
import { RenderingStrategy, } from './ssr-optimization-options';
/**
* Returns the full url for the given SSR Request.
*/
export const getDefaultRenderKey = getRequestUrl;
/**
* The rendered pages are kept in memory to be served on next request. If the `cache` is set to `false`, the
* response is evicted as soon as the first successful response is successfully returned.
*/
export class OptimizedSsrEngine {
constructor(expressEngine, ssrOptions) {
this.expressEngine = expressEngine;
this.ssrOptions = ssrOptions;
this.currentConcurrency = 0;
this.renderingCache = new RenderingCache(this.ssrOptions);
this.templateCache = new Map();
/**
* When the config `reuseCurrentRendering` is enabled, we want perform
* only one render for one rendering key and reuse the html result
* for all the pending requests for the same rendering key.
* Therefore we need to store the callbacks for all the pending requests
* and invoke them with the html after the render completes.
*
* This Map should be used only when `reuseCurrentRendering` config is enabled.
* It's indexed by the rendering keys.
*/
this.renderCallbacks = new Map();
}
get engineInstance() {
return this.renderResponse.bind(this);
}
/**
* When SSR page can not be returned in time, we're returning index.html of
* the CSR application.
* The CSR application is returned with the "Cache-Control: no-store" response-header. This notifies external cache systems to not use the CSR application for the subsequent request.
*/
fallbackToCsr(response, filePath, callback) {
response.set('Cache-Control', 'no-store');
callback(undefined, this.getDocument(filePath));
}
getRenderingKey(request) {
var _a;
return ((_a = this.ssrOptions) === null || _a === void 0 ? void 0 : _a.renderKeyResolver)
? this.ssrOptions.renderKeyResolver(request)
: getDefaultRenderKey(request);
}
getRenderingStrategy(request) {
var _a;
return ((_a = this.ssrOptions) === null || _a === void 0 ? void 0 : _a.renderingStrategyResolver)
? this.ssrOptions.renderingStrategyResolver(request)
: RenderingStrategy.DEFAULT;
}
/**
* When returns true, the server side rendering should be performed.
* When returns false, the CSR fallback should be returned.
*
* We should not render, when there is already
* a pending rendering for the same rendering key
* (unless the `reuseCurrentRendering` config option is enabled)
* OR when the concurrency limit is exceeded.
*/
shouldRender(request) {
var _a, _b;
const renderingKey = this.getRenderingKey(request);
const concurrencyLimitExceeded = this.isConcurrencyLimitExceeded(renderingKey);
const fallBack = this.renderingCache.isRendering(renderingKey) &&
!((_a = this.ssrOptions) === null || _a === void 0 ? void 0 : _a.reuseCurrentRendering);
if (fallBack) {
this.log(`CSR fallback: rendering in progress (${request === null || request === void 0 ? void 0 : request.originalUrl})`);
}
else if (concurrencyLimitExceeded) {
this.log(`CSR fallback: Concurrency limit exceeded (${(_b = this.ssrOptions) === null || _b === void 0 ? void 0 : _b.concurrency})`);
}
return ((!fallBack &&
!concurrencyLimitExceeded &&
this.getRenderingStrategy(request) !== RenderingStrategy.ALWAYS_CSR) ||
this.getRenderingStrategy(request) === RenderingStrategy.ALWAYS_SSR);
}
/**
* Checks for the concurrency limit
*
* @returns true if rendering this request would exceed the concurrency limit
*/
isConcurrencyLimitExceeded(renderingKey) {
var _a, _b;
// If we can reuse a pending render for this request, we don't take up a new concurrency slot.
// In that case we don't exceed the concurrency limit even if the `currentConcurrency`
// already reaches the limit.
if (((_a = this.ssrOptions) === null || _a === void 0 ? void 0 : _a.reuseCurrentRendering) &&
this.renderingCache.isRendering(renderingKey)) {
return false;
}
return ((_b = this.ssrOptions) === null || _b === void 0 ? void 0 : _b.concurrency)
? this.currentConcurrency >= this.ssrOptions.concurrency
: false;
}
/**
* Returns true, when the `timeout` option has been configured to non-zero value OR
* when the rendering strategy for the given request is ALWAYS_SSR.
* Otherwise, it returns false.
*/
shouldTimeout(request) {
var _a;
return (!!((_a = this.ssrOptions) === null || _a === void 0 ? void 0 : _a.timeout) ||
this.getRenderingStrategy(request) === RenderingStrategy.ALWAYS_SSR);
}
/**
* Returns the timeout value.
*
* In case of the rendering strategy ALWAYS_SSR, it returns the config `forcedSsrTimeout`.
* Otherwise, it returns the config `timeout`.
*/
getTimeout(request) {
var _a, _b, _c, _d;
return this.getRenderingStrategy(request) === RenderingStrategy.ALWAYS_SSR
? (_b = (_a = this.ssrOptions) === null || _a === void 0 ? void 0 : _a.forcedSsrTimeout) !== null && _b !== void 0 ? _b : 60000
: (_d = (_c = this.ssrOptions) === null || _c === void 0 ? void 0 : _c.timeout) !== null && _d !== void 0 ? _d : 0;
}
/**
* If there is an available cached response for this rendering key,
* it invokes the given render callback with the response and returns true.
*
* Otherwise, it returns false.
*/
returnCachedRender(request, callback) {
var _a;
const key = this.getRenderingKey(request);
if (this.renderingCache.isReady(key)) {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
const cached = this.renderingCache.get(key);
callback(cached.err, cached.html);
if (!((_a = this.ssrOptions) === null || _a === void 0 ? void 0 : _a.cache)) {
// we drop cached rendering if caching is disabled
this.renderingCache.clear(key);
}
return true;
}
return false;
}
/**
* Handles the request and invokes the given `callback` with the result html / error.
*
* The result might be ether:
* - a CSR fallback with a basic `index.html` content
* - a result rendered by the original Angular Universal express engine
* - a result from the in-memory cache (which was previously rendered by Angular Universal express engine).
*/
renderResponse(filePath, options, callback) {
const request = options.req;
const response = options.res || options.req.res;
if (this.returnCachedRender(request, callback)) {
this.log(`Render from cache (${request === null || request === void 0 ? void 0 : request.originalUrl})`);
return;
}
if (!this.shouldRender(request)) {
this.fallbackToCsr(response, filePath, callback);
return;
}
let requestTimeout;
if (this.shouldTimeout(request)) {
// establish timeout for rendering
const timeout = this.getTimeout(request);
requestTimeout = setTimeout(() => {
requestTimeout = undefined;
this.fallbackToCsr(response, filePath, callback);
this.log(`SSR rendering exceeded timeout ${timeout}, fallbacking to CSR for ${request === null || request === void 0 ? void 0 : request.originalUrl}`, false);
}, timeout);
}
else {
// Here we respond with the fallback to CSR, but we don't `return`.
// We let the actual rendering task to happen in the background
// to eventually store the rendered result in the cache.
this.fallbackToCsr(response, filePath, callback);
}
const renderingKey = this.getRenderingKey(request);
const renderCallback = (err, html) => {
var _a;
if (requestTimeout) {
// if request is still waiting for render, return it
clearTimeout(requestTimeout);
callback(err, html);
this.log(`Request is resolved with the SSR rendering result (${request === null || request === void 0 ? void 0 : request.originalUrl})`);
// store the render only if caching is enabled
if ((_a = this.ssrOptions) === null || _a === void 0 ? void 0 : _a.cache) {
this.renderingCache.store(renderingKey, err, html);
}
else {
this.renderingCache.clear(renderingKey);
}
}
else {
// store the render for future use
this.renderingCache.store(renderingKey, err, html);
}
};
this.handleRender({
filePath,
options,
renderCallback,
request,
});
}
log(message, debug = true) {
var _a;
if (!debug || ((_a = this.ssrOptions) === null || _a === void 0 ? void 0 : _a.debug)) {
console.log(message);
}
}
/** Retrieve the document from the cache or the filesystem */
getDocument(filePath) {
let doc = this.templateCache.get(filePath);
if (!doc) {
// fs.readFileSync could be missing in a browser, specifically
// in a unit tests with { node: { fs: 'empty' } } webpack configuration
doc = (fs === null || fs === void 0 ? void 0 : fs.readFileSync) ? fs.readFileSync(filePath, 'utf-8') : '';
this.templateCache.set(filePath, doc);
}
return doc;
}
/**
* Delegates the render to the original _Angular Universal express engine_.
*
* In case when the config `reuseCurrentRendering` is enabled and **if there is already a pending
* render task for the same rendering key**, it doesn't delegate a new render to Angular Universal.
* Instead, it waits for the current rendering to complete and then reuse the result for all waiting requests.
*/
handleRender({ filePath, options, renderCallback, request, }) {
var _a, _b;
if (!((_a = this.ssrOptions) === null || _a === void 0 ? void 0 : _a.reuseCurrentRendering)) {
this.startRender({
filePath,
options,
renderCallback,
request,
});
return;
}
const renderingKey = this.getRenderingKey(request);
if (!this.renderCallbacks.has(renderingKey)) {
this.renderCallbacks.set(renderingKey, []);
}
(_b = this.renderCallbacks.get(renderingKey)) === null || _b === void 0 ? void 0 : _b.push(renderCallback);
if (!this.renderingCache.isRendering(renderingKey)) {
this.startRender({
filePath,
options,
request,
renderCallback: (err, html) => {
// Share the result of the render with all awaiting requests for the same key:
var _a;
// Note: we access the Map at the moment of the render finished (don't store value in a local variable),
// because in the meantime something might have deleted the value (i.e. when `maxRenderTime` passed).
(_a = this.renderCallbacks
.get(renderingKey)) === null || _a === void 0 ? void 0 : _a.forEach((cb) => cb(err, html)); // pass the shared result to all waiting rendering callbacks
this.renderCallbacks.delete(renderingKey);
},
});
}
this.log(`Request is waiting for the SSR rendering to complete (${request === null || request === void 0 ? void 0 : request.originalUrl})`);
}
/**
* Delegates the render to the original _Angular Universal express engine_.
*
* There is no way to abort the running render of Angular Universal.
* So if the render doesn't complete in the configured `maxRenderTime`,
* we just consider the render task as hanging (note: it's a potential memory leak!).
* Later on, even if the render completes somewhen in the future, we will ignore
* its result.
*/
startRender({ filePath, options, renderCallback, request, }) {
var _a, _b;
const renderingKey = this.getRenderingKey(request);
// Setting the timeout for hanging renders that might not ever finish due to various reasons.
// After the configured `maxRenderTime` passes, we consider the rendering task as hanging,
// and release the concurrency slot and forget all callbacks waiting for the render's result.
let maxRenderTimeout = setTimeout(() => {
var _a;
this.renderingCache.clear(renderingKey);
maxRenderTimeout = undefined;
this.currentConcurrency--;
if ((_a = this.ssrOptions) === null || _a === void 0 ? void 0 : _a.reuseCurrentRendering) {
this.renderCallbacks.delete(renderingKey);
}
this.log(`Rendering of ${request === null || request === void 0 ? void 0 : request.originalUrl} was not able to complete. This might cause memory leaks!`, false);
}, (_b = (_a = this.ssrOptions) === null || _a === void 0 ? void 0 : _a.maxRenderTime) !== null && _b !== void 0 ? _b : 300000); // 300000ms == 5 minutes
this.log(`Rendering started (${request === null || request === void 0 ? void 0 : request.originalUrl})`);
this.renderingCache.setAsRendering(renderingKey);
this.currentConcurrency++;
this.expressEngine(filePath, options, (err, html) => {
if (!maxRenderTimeout) {
// ignore this render's result because it exceeded maxRenderTimeout
this.log(`Rendering of ${request.originalUrl} completed after the specified maxRenderTime, therefore it was ignored.`, false);
return;
}
clearTimeout(maxRenderTimeout);
this.log(`Rendering completed (${request === null || request === void 0 ? void 0 : request.originalUrl})`);
this.currentConcurrency--;
renderCallback(err, html);
});
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"optimized-ssr-engine.js","sourceRoot":"","sources":["../../../../../core-libs/setup/ssr/optimized-engine/optimized-ssr-engine.ts"],"names":[],"mappings":"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","sourcesContent":["/* webpackIgnore: true */\nimport { Request, Response } from 'express';\nimport * as fs from 'fs';\nimport { NgExpressEngineInstance } from '../engine-decorator/ng-express-engine-decorator';\nimport { getRequestUrl } from '../util/request-url';\nimport { RenderingCache } from './rendering-cache';\nimport {\n  RenderingStrategy,\n  SsrOptimizationOptions,\n} from './ssr-optimization-options';\n\n/**\n * Returns the full url for the given SSR Request.\n */\nexport const getDefaultRenderKey = getRequestUrl;\n\nexport type SsrCallbackFn = (\n  /**\n   * Error that might've occurred while rendering.\n   */\n  err?: Error | null | undefined,\n  /**\n   * HTML response.\n   */\n  html?: string | undefined\n) => void;\n\n/**\n * The rendered pages are kept in memory to be served on next request. If the `cache` is set to `false`, the\n * response is evicted as soon as the first successful response is successfully returned.\n */\nexport class OptimizedSsrEngine {\n  protected currentConcurrency = 0;\n  protected renderingCache = new RenderingCache(this.ssrOptions);\n  private templateCache = new Map<string, string>();\n\n  /**\n   * When the config `reuseCurrentRendering` is enabled, we want perform\n   * only one render for one rendering key and reuse the html result\n   * for all the pending requests for the same rendering key.\n   * Therefore we need to store the callbacks for all the pending requests\n   * and invoke them with the html after the render completes.\n   *\n   * This Map should be used only when `reuseCurrentRendering` config is enabled.\n   * It's indexed by the rendering keys.\n   */\n  private renderCallbacks = new Map<string, SsrCallbackFn[]>();\n\n  get engineInstance(): NgExpressEngineInstance {\n    return this.renderResponse.bind(this);\n  }\n\n  constructor(\n    protected expressEngine: NgExpressEngineInstance,\n    protected ssrOptions?: SsrOptimizationOptions\n  ) {}\n\n  /**\n   * When SSR page can not be returned in time, we're returning index.html of\n   * the CSR application.\n   * The CSR application is returned with the \"Cache-Control: no-store\" response-header. This notifies external cache systems to not use the CSR application for the subsequent request.\n   */\n  protected fallbackToCsr(\n    response: Response,\n    filePath: string,\n    callback: SsrCallbackFn\n  ): void {\n    response.set('Cache-Control', 'no-store');\n    callback(undefined, this.getDocument(filePath));\n  }\n\n  protected getRenderingKey(request: Request): string {\n    return this.ssrOptions?.renderKeyResolver\n      ? this.ssrOptions.renderKeyResolver(request)\n      : getDefaultRenderKey(request);\n  }\n\n  protected getRenderingStrategy(request: Request): RenderingStrategy {\n    return this.ssrOptions?.renderingStrategyResolver\n      ? this.ssrOptions.renderingStrategyResolver(request)\n      : RenderingStrategy.DEFAULT;\n  }\n\n  /**\n   * When returns true, the server side rendering should be performed.\n   * When returns false, the CSR fallback should be returned.\n   *\n   * We should not render, when there is already\n   * a pending rendering for the same rendering key\n   * (unless the `reuseCurrentRendering` config option is enabled)\n   * OR when the concurrency limit is exceeded.\n   */\n  protected shouldRender(request: Request): boolean {\n    const renderingKey = this.getRenderingKey(request);\n    const concurrencyLimitExceeded =\n      this.isConcurrencyLimitExceeded(renderingKey);\n    const fallBack =\n      this.renderingCache.isRendering(renderingKey) &&\n      !this.ssrOptions?.reuseCurrentRendering;\n\n    if (fallBack) {\n      this.log(`CSR fallback: rendering in progress (${request?.originalUrl})`);\n    } else if (concurrencyLimitExceeded) {\n      this.log(\n        `CSR fallback: Concurrency limit exceeded (${this.ssrOptions?.concurrency})`\n      );\n    }\n\n    return (\n      (!fallBack &&\n        !concurrencyLimitExceeded &&\n        this.getRenderingStrategy(request) !== RenderingStrategy.ALWAYS_CSR) ||\n      this.getRenderingStrategy(request) === RenderingStrategy.ALWAYS_SSR\n    );\n  }\n\n  /**\n   * Checks for the concurrency limit\n   *\n   * @returns true if rendering this request would exceed the concurrency limit\n   */\n  private isConcurrencyLimitExceeded(renderingKey: string): boolean {\n    // If we can reuse a pending render for this request, we don't take up a new concurrency slot.\n    // In that case we don't exceed the concurrency limit even if the `currentConcurrency`\n    // already reaches the limit.\n    if (\n      this.ssrOptions?.reuseCurrentRendering &&\n      this.renderingCache.isRendering(renderingKey)\n    ) {\n      return false;\n    }\n\n    return this.ssrOptions?.concurrency\n      ? this.currentConcurrency >= this.ssrOptions.concurrency\n      : false;\n  }\n\n  /**\n   * Returns true, when the `timeout` option has been configured to non-zero value OR\n   * when the rendering strategy for the given request is ALWAYS_SSR.\n   * Otherwise, it returns false.\n   */\n  protected shouldTimeout(request: Request): boolean {\n    return (\n      !!this.ssrOptions?.timeout ||\n      this.getRenderingStrategy(request) === RenderingStrategy.ALWAYS_SSR\n    );\n  }\n\n  /**\n   * Returns the timeout value.\n   *\n   * In case of the rendering strategy ALWAYS_SSR, it returns the config `forcedSsrTimeout`.\n   * Otherwise, it returns the config `timeout`.\n   */\n  protected getTimeout(request: Request): number {\n    return this.getRenderingStrategy(request) === RenderingStrategy.ALWAYS_SSR\n      ? this.ssrOptions?.forcedSsrTimeout ?? 60000\n      : this.ssrOptions?.timeout ?? 0;\n  }\n\n  /**\n   * If there is an available cached response for this rendering key,\n   * it invokes the given render callback with the response and returns true.\n   *\n   * Otherwise, it returns false.\n   */\n  protected returnCachedRender(\n    request: Request,\n    callback: SsrCallbackFn\n  ): boolean {\n    const key = this.getRenderingKey(request);\n\n    if (this.renderingCache.isReady(key)) {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      const cached = this.renderingCache.get(key)!;\n      callback(cached.err, cached.html);\n\n      if (!this.ssrOptions?.cache) {\n        // we drop cached rendering if caching is disabled\n        this.renderingCache.clear(key);\n      }\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * Handles the request and invokes the given `callback` with the result html / error.\n   *\n   * The result might be ether:\n   * - a CSR fallback with a basic `index.html` content\n   * - a result rendered by the original Angular Universal express engine\n   * - a result from the in-memory cache (which was previously rendered by Angular Universal express engine).\n   */\n  protected renderResponse(\n    filePath: string,\n    options: any,\n    callback: SsrCallbackFn\n  ): void {\n    const request: Request = options.req;\n    const response: Response = options.res || options.req.res;\n\n    if (this.returnCachedRender(request, callback)) {\n      this.log(`Render from cache (${request?.originalUrl})`);\n      return;\n    }\n    if (!this.shouldRender(request)) {\n      this.fallbackToCsr(response, filePath, callback);\n      return;\n    }\n\n    let requestTimeout: NodeJS.Timeout | undefined;\n    if (this.shouldTimeout(request)) {\n      // establish timeout for rendering\n      const timeout = this.getTimeout(request);\n      requestTimeout = setTimeout(() => {\n        requestTimeout = undefined;\n        this.fallbackToCsr(response, filePath, callback);\n        this.log(\n          `SSR rendering exceeded timeout ${timeout}, fallbacking to CSR for ${request?.originalUrl}`,\n          false\n        );\n      }, timeout);\n    } else {\n      // Here we respond with the fallback to CSR, but we don't `return`.\n      // We let the actual rendering task to happen in the background\n      // to eventually store the rendered result in the cache.\n      this.fallbackToCsr(response, filePath, callback);\n    }\n\n    const renderingKey = this.getRenderingKey(request);\n    const renderCallback: SsrCallbackFn = (err, html): void => {\n      if (requestTimeout) {\n        // if request is still waiting for render, return it\n        clearTimeout(requestTimeout);\n        callback(err, html);\n\n        this.log(\n          `Request is resolved with the SSR rendering result (${request?.originalUrl})`\n        );\n\n        // store the render only if caching is enabled\n        if (this.ssrOptions?.cache) {\n          this.renderingCache.store(renderingKey, err, html);\n        } else {\n          this.renderingCache.clear(renderingKey);\n        }\n      } else {\n        // store the render for future use\n        this.renderingCache.store(renderingKey, err, html);\n      }\n    };\n\n    this.handleRender({\n      filePath,\n      options,\n      renderCallback,\n      request,\n    });\n  }\n\n  protected log(message: string, debug = true): void {\n    if (!debug || this.ssrOptions?.debug) {\n      console.log(message);\n    }\n  }\n\n  /** Retrieve the document from the cache or the filesystem */\n  protected getDocument(filePath: string): string {\n    let doc = this.templateCache.get(filePath);\n\n    if (!doc) {\n      // fs.readFileSync could be missing in a browser, specifically\n      // in a unit tests with { node: { fs: 'empty' } } webpack configuration\n      doc = fs?.readFileSync ? fs.readFileSync(filePath, 'utf-8') : '';\n      this.templateCache.set(filePath, doc);\n    }\n\n    return doc;\n  }\n\n  /**\n   * Delegates the render to the original _Angular Universal express engine_.\n   *\n   * In case when the config `reuseCurrentRendering` is enabled and **if there is already a pending\n   * render task for the same rendering key**, it doesn't delegate a new render to Angular Universal.\n   * Instead, it waits for the current rendering to complete and then reuse the result for all waiting requests.\n   */\n  private handleRender({\n    filePath,\n    options,\n    renderCallback,\n    request,\n  }: {\n    filePath: string;\n    options: any;\n    renderCallback: SsrCallbackFn;\n    request: Request;\n  }): void {\n    if (!this.ssrOptions?.reuseCurrentRendering) {\n      this.startRender({\n        filePath,\n        options,\n        renderCallback,\n        request,\n      });\n      return;\n    }\n\n    const renderingKey = this.getRenderingKey(request);\n    if (!this.renderCallbacks.has(renderingKey)) {\n      this.renderCallbacks.set(renderingKey, []);\n    }\n    this.renderCallbacks.get(renderingKey)?.push(renderCallback);\n\n    if (!this.renderingCache.isRendering(renderingKey)) {\n      this.startRender({\n        filePath,\n        options,\n        request,\n        renderCallback: (err, html) => {\n          // Share the result of the render with all awaiting requests for the same key:\n\n          // Note: we access the Map at the moment of the render finished (don't store value in a local variable),\n          //       because in the meantime something might have deleted the value (i.e. when `maxRenderTime` passed).\n          this.renderCallbacks\n            .get(renderingKey)\n            ?.forEach((cb) => cb(err, html)); // pass the shared result to all waiting rendering callbacks\n          this.renderCallbacks.delete(renderingKey);\n        },\n      });\n    }\n\n    this.log(\n      `Request is waiting for the SSR rendering to complete (${request?.originalUrl})`\n    );\n  }\n\n  /**\n   * Delegates the render to the original _Angular Universal express engine_.\n   *\n   * There is no way to abort the running render of Angular Universal.\n   * So if the render doesn't complete in the configured `maxRenderTime`,\n   * we just consider the render task as hanging (note: it's a potential memory leak!).\n   * Later on, even if the render completes somewhen in the future, we will ignore\n   * its result.\n   */\n  private startRender({\n    filePath,\n    options,\n    renderCallback,\n    request,\n  }: {\n    filePath: string;\n    options: any;\n    renderCallback: SsrCallbackFn;\n    request: Request;\n  }): void {\n    const renderingKey = this.getRenderingKey(request);\n\n    // Setting the timeout for hanging renders that might not ever finish due to various reasons.\n    // After the configured `maxRenderTime` passes, we consider the rendering task as hanging,\n    // and release the concurrency slot and forget all callbacks waiting for the render's result.\n    let maxRenderTimeout: NodeJS.Timeout | undefined = setTimeout(() => {\n      this.renderingCache.clear(renderingKey);\n      maxRenderTimeout = undefined;\n      this.currentConcurrency--;\n      if (this.ssrOptions?.reuseCurrentRendering) {\n        this.renderCallbacks.delete(renderingKey);\n      }\n      this.log(\n        `Rendering of ${request?.originalUrl} was not able to complete. This might cause memory leaks!`,\n        false\n      );\n    }, this.ssrOptions?.maxRenderTime ?? 300000); // 300000ms == 5 minutes\n\n    this.log(`Rendering started (${request?.originalUrl})`);\n    this.renderingCache.setAsRendering(renderingKey);\n    this.currentConcurrency++;\n\n    this.expressEngine(filePath, options, (err, html) => {\n      if (!maxRenderTimeout) {\n        // ignore this render's result because it exceeded maxRenderTimeout\n        this.log(\n          `Rendering of ${request.originalUrl} completed after the specified maxRenderTime, therefore it was ignored.`,\n          false\n        );\n        return;\n      }\n      clearTimeout(maxRenderTimeout);\n\n      this.log(`Rendering completed (${request?.originalUrl})`);\n      this.currentConcurrency--;\n\n      renderCallback(err, html);\n    });\n  }\n}\n"]}