fix: Introducing initializers for handling lock cleanup on start

src/init/App.ts

@@ -1,5 +1,5 @@
 import type { ClusterManager } from './cluster/ClusterManager';
-import type { Finalizable } from './final/Finalizable';
+import type { Finalizer } from './final/Finalizer';
 import type { Initializer } from './Initializer';
 
 /**
@@ -7,10 +7,10 @@ import type { Initializer } from './Initializer';
  */
 export class App {
   private readonly initializer: Initializer;
-  private readonly finalizer: Finalizable;
+  private readonly finalizer: Finalizer;
   public readonly clusterManager: ClusterManager;
 
-  public constructor(initializer: Initializer, finalizer: Finalizable, clusterManager: ClusterManager) {
+  public constructor(initializer: Initializer, finalizer: Finalizer, clusterManager: ClusterManager) {
     this.initializer = initializer;
     this.finalizer = finalizer;
     this.clusterManager = clusterManager;
@@ -27,6 +27,6 @@ export class App {
    * Stops the application and handles cleanup.
    */
   public async stop(): Promise<void> {
-    await this.finalizer.finalize();
+    await this.finalizer.handleSafe();
   }
 }

src/init/Initializable.ts

@@ -0,0 +1,8 @@
+/**
+ * Allows for initializing state or executing logic when the application is started.
+ * Use this interface to add initialization logic to classes that already extend some other type.
+ * NOTE: classes without an existing extends-relation should extend from Initializer instead!
+ */
+export interface Initializable {
+  initialize: () => Promise<void>;
+}

src/init/InitializableHandler.ts

@@ -0,0 +1,18 @@
+import type { Initializable } from './Initializable';
+import { Initializer } from './Initializer';
+
+/**
+ * Allows using an Initializable as an Initializer Handler.
+ */
+export class InitializableHandler extends Initializer {
+  protected readonly initializable: Initializable;
+
+  public constructor(initializable: Initializable) {
+    super();
+    this.initializable = initializable;
+  }
+
+  public async handle(): Promise<void> {
+    return this.initializable.initialize();
+  }
+}

src/init/Initializer.ts

@@ -1,3 +1,6 @@
 import { AsyncHandler } from '../util/handlers/AsyncHandler';
 
+/**
+ * Initializer is used to indicate an AsyncHandler that performs initialization logic.
+ */
 export abstract class Initializer extends AsyncHandler {}

src/init/final/Finalizable.ts

@@ -1,5 +1,7 @@
 /**
  * Allows for cleaning up an object and stopping relevant loops when the application needs to be stopped.
+ * Use this interface to add finalization logic to classes that already extend some other type.
+ * NOTE: classes without an existing extends-relation should extend from Finalizer instead!
  */
 export interface Finalizable {
   finalize: () => Promise<void>;

src/init/final/FinalizableHandler.ts

@@ -0,0 +1,18 @@
+import type { Finalizable } from './Finalizable';
+import { Finalizer } from './Finalizer';
+
+/**
+ * Allows using a Finalizable as a Finalizer Handler.
+ */
+export class FinalizableHandler extends Finalizer {
+  protected readonly finalizable: Finalizable;
+
+  public constructor(finalizable: Finalizable) {
+    super();
+    this.finalizable = finalizable;
+  }
+
+  public async handle(): Promise<void> {
+    return this.finalizable.finalize();
+  }
+}

src/init/final/Finalizer.ts

@@ -0,0 +1,6 @@
+import { AsyncHandler } from '../../util/handlers/AsyncHandler';
+
+/**
+ * Finalizer is used to indicate an AsyncHandler that performs finalization logic.
+ */
+export abstract class Finalizer extends AsyncHandler {}

src/init/final/ParallelFinalizer.ts

@@ -1,16 +0,0 @@
-import type { Finalizable } from './Finalizable';
-
-/**
- * Finalizes all the injected Finalizable classes in parallel.
- */
-export class ParallelFinalizer implements Finalizable {
-  private readonly finalizers: Finalizable[];
-
-  public constructor(finalizers: Finalizable[] = []) {
-    this.finalizers = finalizers;
-  }
-
-  public async finalize(): Promise<void> {
-    await Promise.all(this.finalizers.map(async(finalizer): Promise<void> => finalizer.finalize()));
-  }
-}