feat(async-ssr-manager): use Logger Feature Service instead of console (

#415)

The integrator can now provide the Logger Feature Service, which the Async SSR Manager then uses for logging. The Async SSR Manager declares the Logger Feature Service as an optional dependency, and uses console as a fallback logger, when the Logger Feature Service is not provided.

packages/async-ssr-manager/package.json

@@ -21,7 +21,8 @@
   "module": "lib/esm/index.js",
   "typings": "lib/cjs/index.d.ts",
   "dependencies": {
-    "@feature-hub/core": "^1.1.0"
+    "@feature-hub/core": "^1.1.0",
+    "@feature-hub/logger": "^0.0.0"
   },
   "devDependencies": {
     "jest-stub-methods": "^0.2.1"

packages/async-ssr-manager/src/__tests__/index.test.ts

@@ -1,12 +1,13 @@
 // tslint:disable:no-implicit-dependencies
 
 import {FeatureAppEnvironment, FeatureServiceBinder} from '@feature-hub/core';
-import {stubMethods} from 'jest-stub-methods';
+import {Stubbed, stubMethods} from 'jest-stub-methods';
 import {
   AsyncSsrManagerConfig,
   AsyncSsrManagerV1,
   asyncSsrManagerDefinition
 } from '..';
+import {stubbedLogger} from './stubbed-logger';
 import {useFakeTimers} from './use-fake-timers';
 
 const queueMacroTask = setImmediate;
@@ -23,7 +24,7 @@ describe('asyncSsrManagerDefinition', () => {
   beforeEach(() => {
     mockEnv = {
       config: {timeout: 5},
-      featureServices: {},
+      featureServices: {'s2:logger': stubbedLogger},
       idSpecifier: undefined,
       instanceConfig: undefined
     };
@@ -33,9 +34,12 @@ describe('asyncSsrManagerDefinition', () => {
     expect(asyncSsrManagerDefinition.id).toBe('s2:async-ssr-manager');
   });
 
-  it('has no dependencies', () => {
+  it('defines its dependencies', () => {
     expect(asyncSsrManagerDefinition.dependencies).toBeUndefined();
-    expect(asyncSsrManagerDefinition.optionalDependencies).toBeUndefined();
+
+    expect(asyncSsrManagerDefinition.optionalDependencies).toEqual({
+      featureServices: {'s2:logger': '^1.0.0'}
+    });
   });
 
   describe('#create', () => {
@@ -292,7 +296,7 @@ describe('asyncSsrManagerDefinition', () => {
         beforeEach(() => {
           asyncSsrManagerBinder = asyncSsrManagerDefinition.create({
             config: undefined,
-            featureServices: {}
+            featureServices: {'s2:logger': stubbedLogger}
           })['1.0.0'];
         });
 
@@ -305,13 +309,47 @@ describe('asyncSsrManagerDefinition', () => {
             asyncSsrManager.renderUntilCompleted(mockRender)
           );
 
-          expect(console.warn).toHaveBeenCalledWith(
-            'No timeout is configured for the Async SSR Manager. This could lead to unexpectedly long render times or, in the worst case, never resolving render calls!'
-          );
+          expect(stubbedLogger.warn.mock.calls).toEqual([
+            [
+              'No timeout is configured for the Async SSR Manager. This could lead to unexpectedly long render times or, in the worst case, never resolving render calls!'
+            ]
+          ]);
 
           stubbedConsole.restore();
         });
       });
     });
+
+    describe('when no Logger Feature Service is provided', () => {
+      let stubbedConsole: Stubbed<Console>;
+
+      beforeEach(() => {
+        stubbedConsole = stubMethods(console);
+
+        asyncSsrManagerBinder = asyncSsrManagerDefinition.create({
+          config: undefined,
+          featureServices: {}
+        })['1.0.0'];
+      });
+
+      afterEach(() => {
+        stubbedConsole.restore();
+      });
+
+      it('logs messages using the console', async () => {
+        const asyncSsrManager = asyncSsrManagerBinder('test').featureService;
+        const mockRender = jest.fn(() => 'testHtml');
+
+        await useFakeTimers(async () =>
+          asyncSsrManager.renderUntilCompleted(mockRender)
+        );
+
+        expect(stubbedConsole.stub.warn.mock.calls).toEqual([
+          [
+            'No timeout is configured for the Async SSR Manager. This could lead to unexpectedly long render times or, in the worst case, never resolving render calls!'
+          ]
+        ]);
+      });
+    });
   });
 });

packages/async-ssr-manager/src/__tests__/stubbed-logger.ts

@@ -0,0 +1,12 @@
+// tslint:disable:no-implicit-dependencies
+
+import {Logger} from '@feature-hub/logger';
+import {Stub} from 'jest-stub-methods';
+
+export const stubbedLogger: Stub<Logger> = {
+  trace: jest.fn(),
+  debug: jest.fn(),
+  info: jest.fn(),
+  warn: jest.fn(),
+  error: jest.fn()
+};

packages/async-ssr-manager/src/index.ts

@@ -1,9 +1,12 @@
 import {
   FeatureServiceBinder,
   FeatureServiceProviderDefinition,
+  FeatureServices,
   SharedFeatureService
 } from '@feature-hub/core';
+import {Logger} from '@feature-hub/logger';
 import {AsyncSsrManager} from './internal/async-ssr-manager';
+import {createAsyncSsrManagerContext} from './internal/async-ssr-manager-context';
 import {validateConfig} from './internal/validate-config';
 
 export interface AsyncSsrManagerConfig {
@@ -83,19 +86,32 @@ export interface SharedAsyncSsrManager extends SharedFeatureService {
   readonly '1.0.0': FeatureServiceBinder<AsyncSsrManagerV1>;
 }
 
+export interface AsyncSsrManagerDependencies extends FeatureServices {
+  readonly 's2:logger'?: Logger;
+}
+
 /**
  * @see {@link AsyncSsrManagerV1} for further information.
  */
 export const asyncSsrManagerDefinition: FeatureServiceProviderDefinition<
-  SharedAsyncSsrManager
+  SharedAsyncSsrManager,
+  AsyncSsrManagerDependencies
 > = {
   id: 's2:async-ssr-manager',
 
+  optionalDependencies: {
+    featureServices: {
+      's2:logger': '^1.0.0'
+    }
+  },
+
   create: env => {
+    const context = createAsyncSsrManagerContext(env.featureServices);
+
     const {timeout} =
       validateConfig(env.config) || ({} as AsyncSsrManagerConfig);
 
-    const asyncSsrManager = new AsyncSsrManager(timeout);
+    const asyncSsrManager = new AsyncSsrManager(context, timeout);
 
     return {
       '1.0.0': () => ({featureService: asyncSsrManager})

packages/async-ssr-manager/src/internal/async-ssr-manager-context.ts

@@ -0,0 +1,14 @@
+import {Logger} from '@feature-hub/logger';
+import {AsyncSsrManagerDependencies} from '..';
+
+export interface AsyncSsrManagerContext {
+  readonly logger: Logger;
+}
+
+export function createAsyncSsrManagerContext(
+  featureServices: AsyncSsrManagerDependencies
+): AsyncSsrManagerContext {
+  const logger = featureServices['s2:logger'] || console;
+
+  return {logger};
+}

packages/async-ssr-manager/src/internal/async-ssr-manager.ts

@@ -1,4 +1,5 @@
 import {AsyncSsrManagerV1} from '..';
+import {AsyncSsrManagerContext} from './async-ssr-manager-context';
 import {setTimeoutAsync} from './set-timeout-async';
 
 async function renderingTimeout(timeout: number): Promise<never> {
@@ -10,13 +11,16 @@ async function renderingTimeout(timeout: number): Promise<never> {
 export class AsyncSsrManager implements AsyncSsrManagerV1 {
   private readonly asyncOperations = new Set<Promise<unknown>>();
 
-  public constructor(private readonly timeout?: number) {}
+  public constructor(
+    private readonly context: AsyncSsrManagerContext,
+    private readonly timeout?: number
+  ) {}
 
   public async renderUntilCompleted(render: () => string): Promise<string> {
     const renderPromise = this.renderingLoop(render);
 
     if (typeof this.timeout !== 'number') {
-      console.warn(
+      this.context.logger.warn(
         'No timeout is configured for the Async SSR Manager. This could lead to unexpectedly long render times or, in the worst case, never resolving render calls!'
       );
 
@@ -38,7 +42,7 @@ export class AsyncSsrManager implements AsyncSsrManagerV1 {
     while (this.asyncOperations.size > 0) {
       while (this.asyncOperations.size > 0) {
         // Storing a snapshot of the asynchronous operations and clearing them
-        // afterwards allows that consecutive promises can be added while the
+        // afterwards, allows that consecutive promises can be added while the
         // current asynchronous operations are running.
 
         const asyncOperationsSnapshot = Array.from(