feat(pluginmanager): load container bindings before initializing the plugins

Added an extra ����entry in the plugin description file for defining container bindings which should
be loaded before any plugin is initialized��

Author: YannickFricke

src/plugin/INotedPlugin.ts

@@ -0,0 +1,27 @@
+import { IPluginDescriptorFile } from './IPluginDescriptorFile';
+
+/**
+ * Contains informations about a noted plugin
+ * which should be initialized after the container
+ * bindings are loaded
+ *
+ * @export
+ * @interface INotedPlugin
+ */
+export interface INotedPlugin {
+    /**
+     * The default export of the plugin
+     *
+     * @type {*}
+     * @memberof INotedPlugin
+     */
+    plugin: any;
+
+    /**
+     * The plugin description file
+     *
+     * @type {IPluginDescriptorFile}
+     * @memberof INotedPlugin
+     */
+    pluginDescription: IPluginDescriptorFile;
+}

src/plugin/IPluginDescriptorFile.ts

@@ -50,4 +50,13 @@ export interface IPluginDescriptorFile {
      * @memberof IPluginDescriptorFile
      */
     main: string;
+
+    /**
+     * Contains the path to additional container
+     * bindings for the plugin
+     *
+     * @type {string}
+     * @memberof IPluginDescriptorFile
+     */
+    containerBindings?: string;
 }

src/plugin/PluginManager.ts

@@ -9,6 +9,7 @@ import { EventManager } from '../event/EventManager';
 import { IsNullOrUndefined } from '../Extras';
 import { Logger } from '../logger/Logger';
 import { InitializationSide } from './InitializationSide';
+import { INotedPlugin } from './INotedPlugin';
 import { IPlugin } from './IPlugin';
 import { IPluginDescriptorFile } from './IPluginDescriptorFile';
 
@@ -71,6 +72,17 @@ export class PluginManager {
      */
     private initializationSide: InitializationSide;
 
+    /**
+     * Contains all noted plugins which should
+     * be loaded after the container binding files
+     * were bound
+     *
+     * @private
+     * @type {INotedPlugin[]}
+     * @memberof PluginManager
+     */
+    private notedPlugins: INotedPlugin[];
+
     /**
      * Creates an instance of PluginManager.
      * @param {Logger} logger The logger which should be used from the dependency injection container
@@ -103,6 +115,8 @@ export class PluginManager {
 
         // Set the initialization side
         this.initializationSide = initializationSide;
+
+        this.notedPlugins = [];
     }
 
     /**
@@ -174,9 +188,44 @@ export class PluginManager {
                 continue;
             }
 
+            if (parsedPluginFile.containerBindings === undefined) {
+                continue;
+            }
+
+            if (parsedPluginFile.containerBindings.trim().length === 0) {
+                this.logger.info(`The path to the container bindings for the plugin ${parsedPluginFile.name} is empty`);
+
+                continue;
+            }
+
+            if (parsedPluginFile.containerBindings.includes('..')) {
+                this.logger.warn(`The container bindings for the plugin ${parsedPluginFile.name} are not inside the plugin directory`);
+
+                continue;
+            }
+
+            try {
+                this.loadContainerBindings(
+                    pluginDirectory,
+                    parsedPluginFile.containerBindings,
+                );
+
+                this.notedPlugins.push({
+                    plugin,
+                    pluginDescription: parsedPluginFile,
+                });
+            } catch (error) {
+                this.logger.error(
+                    `Could not load the container bindings for the plugin ${parsedPluginFile.name}`,
+                    error,
+                );
+            }
+        }
+
+        this.notedPlugins.forEach((notedPlugin) => {
             const pluginInstance = this.getPluginInstance(
-                parsedPluginFile,
-                plugin,
+                notedPlugin.pluginDescription,
+                notedPlugin.plugin,
             );
 
             try {
@@ -185,14 +234,17 @@ export class PluginManager {
                     this.initializationSide,
                 );
             } catch (error) {
-                this.logger.error(`Could not call onInit for plugin "${pluginDirectory}"`, error);
+                this.logger.error(
+                    `Could not call onInit for plugin "${notedPlugin.pluginDescription.name}"`,
+                    error,
+                );
 
-                continue;
+                return;
             }
 
             // Add the plugin to the managed plugins
             this.plugins.push(pluginInstance);
-        }
+        });
     }
 
     /**
@@ -327,6 +379,30 @@ export class PluginManager {
         return pluginFunction;
     }
 
+    /**
+     * Loads the container bindings for the given plugin
+     *
+     * @private
+     * @param {string} pluginDirectory The path to the plugin directory
+     * @param {IPluginDescriptorFile} parsedPluginFile The parsed plugin description file
+     * @memberof PluginManager
+     */
+    private loadContainerBindings(
+        pluginDirectory: string,
+        containerBindingsPath: string,
+    ) {
+        const resolvedContainerBindingsPath = resolve(
+            pluginDirectory,
+            containerBindingsPath,
+        );
+
+        const loadedContainerBindings = require(
+            resolvedContainerBindingsPath,
+        );
+
+        loadedContainerBindings(this.container);
+    }
+
     /**
      * Returns an plugin instance which was created with
      * the help of the dependency injection container