fix(platform-server): destroy PlatformRef even if the bootstrap or _render fail

Platonn · Platonn · commit 1b84662677cf · 2024-10-05T00:19:37.000+02:00
diff --git a/packages/platform-server/src/utils.ts b/packages/platform-server/src/utils.ts
@@ -194,18 +194,20 @@ async function _render(platformRef: PlatformRef, applicationRef: ApplicationRef)
   }
 
   appendServerContextInfo(applicationRef);
-  const output = platformState.renderToString();
+  return platformState.renderToString();
+}
 
-  // Destroy the application in a macrotask, this allows pending promises to be settled and errors
-  // to be surfaced to the users.
+/**
+ * Destroy the application in a macrotask, this allows pending promises to be settled and errors
+ * to be surfaced to the users.
+ */
+async function asyncDestroyPlatform(platformRef: PlatformRef): Promise<void> {
   await new Promise<void>((resolve) => {
     setTimeout(() => {
       platformRef.destroy();
       resolve();
     }, 0);
   });
-
-  return output;
 }
 
 /**
@@ -248,9 +250,13 @@ export async function renderModule<T>(
 ): Promise<string> {
   const {document, url, extraProviders: platformProviders} = options;
   const platformRef = createServerPlatform({document, url, platformProviders});
-  const moduleRef = await platformRef.bootstrapModule(moduleType);
-  const applicationRef = moduleRef.injector.get(ApplicationRef);
-  return _render(platformRef, applicationRef);
+  try {
+    const moduleRef = await platformRef.bootstrapModule(moduleType);
+    const applicationRef = moduleRef.injector.get(ApplicationRef);
+    return await _render(platformRef, applicationRef);
+  } finally {
+    await asyncDestroyPlatform(platformRef);
+  }
 }
 
 /**
@@ -279,8 +285,11 @@ export async function renderApplication<T>(
 ): Promise<string> {
   return runAndMeasurePerf('renderApplication', async () => {
     const platformRef = createServerPlatform(options);
-
-    const applicationRef = await bootstrap();
-    return _render(platformRef, applicationRef);
+    try {
+      const applicationRef = await bootstrap();
+      return await _render(platformRef, applicationRef);
+    } finally {
+      await asyncDestroyPlatform(platformRef);
+    }
   });
 }
diff --git a/packages/platform-server/test/integration_spec.ts b/packages/platform-server/test/integration_spec.ts
@@ -42,6 +42,9 @@ import {
   ViewEncapsulation,
   ɵPendingTasks as PendingTasks,
   ɵwhenStable as whenStable,
+  APP_INITIALIZER,
+  inject,
+  getPlatform,
 } from '@angular/core';
 import {SSR_CONTENT_INTEGRITY_MARKER} from '@angular/core/src/hydration/utils';
 import {TestBed} from '@angular/core/testing';
@@ -1076,6 +1079,153 @@ class HiddenModule {}
             );
           },
         );
+
+        it(
+          `should call onOnDestroy of a service after a successful render` +
+            `(standalone: ${isStandalone})`,
+          async () => {
+            let wasServiceNgOnDestroyCalled = false;
+
+            @Injectable({providedIn: 'root'})
+            class DestroyableService {
+              ngOnDestroy() {
+                wasServiceNgOnDestroyCalled = true;
+              }
+            }
+
+            const SuccessfulAppInitializerProviders = [
+              {
+                provide: APP_INITIALIZER,
+                useFactory: () => {
+                  inject(DestroyableService);
+                  return () => Promise.resolve(); // Success in APP_INITIALIZER
+                },
+                multi: true,
+              },
+            ];
+
+            @NgModule({
+              providers: SuccessfulAppInitializerProviders,
+              imports: [MyServerAppModule, ServerModule],
+              bootstrap: [MyServerApp],
+            })
+            class ServerSuccessfulAppInitializerModule {}
+
+            const ServerSuccessfulAppInitializerAppStandalone = getStandaloneBootstrapFn(
+              createMyServerApp(true),
+              SuccessfulAppInitializerProviders,
+            );
+
+            const options = {document: doc};
+            const bootstrap = isStandalone
+              ? renderApplication(ServerSuccessfulAppInitializerAppStandalone, options)
+              : renderModule(ServerSuccessfulAppInitializerModule, options);
+            await bootstrap;
+
+            expect(getPlatform()).withContext('PlatformRef should be destroyed').toBeNull();
+            expect(wasServiceNgOnDestroyCalled)
+              .withContext('DestroyableService.ngOnDestroy() should be called')
+              .toBeTrue();
+          },
+        );
+
+        it(
+          `should call onOnDestroy of a service after some APP_INITIALIZER fails ` +
+            `(standalone: ${isStandalone})`,
+          async () => {
+            let wasServiceNgOnDestroyCalled = false;
+
+            @Injectable({providedIn: 'root'})
+            class DestroyableService {
+              ngOnDestroy() {
+                wasServiceNgOnDestroyCalled = true;
+              }
+            }
+
+            const FailingAppInitializerProviders = [
+              {
+                provide: APP_INITIALIZER,
+                useFactory: () => {
+                  inject(DestroyableService);
+                  return () => Promise.reject('Error in APP_INITIALIZER');
+                },
+                multi: true,
+              },
+            ];
+
+            @NgModule({
+              providers: FailingAppInitializerProviders,
+              imports: [MyServerAppModule, ServerModule],
+              bootstrap: [MyServerApp],
+            })
+            class ServerFailingAppInitializerModule {}
+
+            const ServerFailingAppInitializerAppStandalone = getStandaloneBootstrapFn(
+              createMyServerApp(true),
+              FailingAppInitializerProviders,
+            );
+            debugger;
+            const options = {document: doc};
+            const bootstrap = isStandalone
+              ? renderApplication(ServerFailingAppInitializerAppStandalone, options)
+              : renderModule(ServerFailingAppInitializerModule, options);
+            await expectAsync(bootstrap).toBeRejectedWith('Error in APP_INITIALIZER');
+
+            expect(getPlatform()).withContext('PlatformRef should be destroyed').toBeNull();
+            expect(wasServiceNgOnDestroyCalled)
+              .withContext('DestroyableService.ngOnDestroy() should be called')
+              .toBeTrue();
+          },
+        );
+
+        it(
+          `should call onOnDestroy of a service after an error happens in a root component's constructor ` +
+            `(standalone: ${isStandalone})`,
+          async () => {
+            let wasServiceNgOnDestroyCalled = false;
+
+            @Injectable({providedIn: 'root'})
+            class DestroyableService {
+              ngOnDestroy() {
+                wasServiceNgOnDestroyCalled = true;
+              }
+            }
+
+            @Component({
+              standalone: isStandalone,
+              selector: 'app',
+              template: `Works!`,
+            })
+            class MyServerFailingConstructorApp {
+              constructor() {
+                inject(DestroyableService);
+                throw 'Error in constructor of the root component';
+              }
+            }
+
+            @NgModule({
+              declarations: [MyServerFailingConstructorApp],
+              imports: [MyServerAppModule, ServerModule],
+              bootstrap: [MyServerFailingConstructorApp],
+            })
+            class MyServerFailingConstructorAppModule {}
+
+            const MyServerFailingConstructorAppStandalone = getStandaloneBootstrapFn(
+              MyServerFailingConstructorApp,
+            );
+            const options = {document: doc};
+            const bootstrap = isStandalone
+              ? renderApplication(MyServerFailingConstructorAppStandalone, options)
+              : renderModule(MyServerFailingConstructorAppModule, options);
+            await expectAsync(bootstrap).toBeRejectedWith(
+              'Error in constructor of the root component',
+            );
+            expect(getPlatform()).withContext('PlatformRef should be destroyed').toBeNull();
+            expect(wasServiceNgOnDestroyCalled)
+              .withContext('DestroyableService.ngOnDestroy() should be called')
+              .toBeTrue();
+          },
+        );
       });
     });
 
