feat(core-kernel): implement builder pattern to support driver-based …

…plugins

packages/core-kernel/package.json

@@ -36,6 +36,7 @@
         "micromatch": "^4.0.2",
         "nsfw": "^1.2.5",
         "semver": "^6.3.0",
+        "strman": "^2.0.1",
         "type-fest": "^0.7.1"
     },
     "publishConfig": {

packages/core-kernel/src/application.ts

@@ -43,7 +43,7 @@ export class Application extends Container implements Kernel.IApplication {
     public async bootstrap(config: JsonObject): Promise<void> {
         app.bind<JsonObject>("config", config);
 
-        app.singleton<ProviderRepository>("providers", ProviderRepository);
+        app.singleton<ProviderRepository>("service-providers", ProviderRepository);
 
         await this.runBootstrappers("app");
 
@@ -401,7 +401,7 @@ export class Application extends Container implements Kernel.IApplication {
      * @memberof Application
      */
     private async disposeServiceProviders(): Promise<void> {
-        for (const provider of app.resolve<ProviderRepository>("providers").allLoadedProviders()) {
+        for (const provider of app.resolve<ProviderRepository>("service-providers").allLoadedProviders()) {
             await provider.dispose();
         }
     }

packages/core-kernel/src/bootstrap/app/index.ts

@@ -1,14 +1,15 @@
-export * from "./load-error-handler";
-
-export * from "./load-factories";
-export * from "./load-services";
-
-export * from "./load-bindings";
-export * from "./load-namespace";
-export * from "./load-paths";
-
+// Foundation
+export * from "./register-error-handler";
+export * from "./register-base-service-providers";
+export * from "./register-base-bindings";
+export * from "./register-base-namespace";
+export * from "./register-base-paths";
+export * from "./register-application-service-providers";
+
+// Configuration
 export * from "./load-environment-variables";
 export * from "./load-configuration";
 export * from "./load-cryptography";
 
+// Service Providers
 export * from "./load-service-providers";

packages/core-kernel/src/bootstrap/app/load-configuration.ts

@@ -1,6 +1,5 @@
 import { JsonObject } from "type-fest";
-import { ConfigRepository } from "../../config";
-import { IConfigAdapter } from "../../contracts/core-kernel";
+import { ConfigManager, ConfigRepository } from "../../services/config";
 import { AbstractBootstrapper } from "../bootstrapper";
 
 /**
@@ -17,6 +16,8 @@ export class LoadConfiguration extends AbstractBootstrapper {
 
         this.app.resolve<ConfigRepository>("config").set("options", config.options || {});
 
-        await this.app.resolve<IConfigAdapter>("configLoader").loadConfiguration();
+        await (await this.app
+            .resolve<ConfigManager>("configManager")
+            .driver((config.configLoader || "local") as string)).loadConfiguration();
     }
 }

packages/core-kernel/src/bootstrap/app/load-environment-variables.ts

@@ -1,4 +1,5 @@
-import { Kernel } from "../../contracts";
+import { JsonObject } from "type-fest";
+import { ConfigManager } from "../../services/config";
 import { AbstractBootstrapper } from "../bootstrapper";
 
 /**
@@ -11,6 +12,10 @@ export class LoadEnvironmentVariables extends AbstractBootstrapper {
      * @memberof LoadEnvironmentVariables
      */
     public async bootstrap(): Promise<void> {
-        await this.app.resolve<Kernel.IConfigAdapter>("configLoader").loadEnvironmentVariables();
+        const config: JsonObject = this.app.resolve<JsonObject>("config");
+
+        await (await this.app
+            .resolve<ConfigManager>("configManager")
+            .driver((config.configLoader || "local") as string)).loadEnvironmentVariables();
     }
 }

packages/core-kernel/src/bootstrap/app/load-service-providers.ts

@@ -13,10 +13,10 @@ export class LoadServiceProviders extends AbstractBootstrapper {
      * @memberof RegisterProviders
      */
     public async bootstrap(): Promise<void> {
-        for (const [pkg, opts] of Object.entries(this.app.config("providers"))) {
+        for (const [pkg, opts] of Object.entries(this.app.config("service-providers"))) {
             const provider: AbstractServiceProvider = new (require(pkg)).ServiceProvider(this.app, opts);
 
-            this.app.resolve<ProviderRepository>("providers").set(pkg, provider);
+            this.app.resolve<ProviderRepository>("service-providers").set(pkg, provider);
         }
     }
 }

packages/core-kernel/src/bootstrap/app/register-application-service-providers.ts

@@ -0,0 +1,23 @@
+import { Cache, Filesystem, Log, Queue } from "../../services";
+import { AbstractBootstrapper } from "../bootstrapper";
+
+/**
+ * @export
+ * @class RegisterApplicationServiceProviders
+ */
+export class RegisterApplicationServiceProviders extends AbstractBootstrapper {
+    /**
+     * @param {Kernel.IApplication} app
+     * @returns {Promise<void>}
+     * @memberof RegisterApplicationServiceProviders
+     */
+    public async bootstrap(): Promise<void> {
+        await new Log.ServiceProvider(this.app).register();
+
+        await new Filesystem.ServiceProvider(this.app).register();
+
+        await new Cache.ServiceProvider(this.app).register();
+
+        await new Queue.ServiceProvider(this.app).register();
+    }
+}

packages/core-kernel/src/bootstrap/app/load-bindings.ts → packages/core-kernel/src/bootstrap/app/register-base-bindings.ts

@@ -2,13 +2,13 @@ import { AbstractBootstrapper } from "../bootstrapper";
 
 /**
  * @export
- * @class LoadBindings
+ * @class RegisterBaseBindings
  */
-export class LoadBindings extends AbstractBootstrapper {
+export class RegisterBaseBindings extends AbstractBootstrapper {
     /**
      * @param {Kernel.IApplication} app
      * @returns {Promise<void>}
-     * @memberof LoadBindings
+     * @memberof RegisterBaseBindings
      */
     public async bootstrap(): Promise<void> {
         this.app.bind("app.env", this.app.config("env"));

packages/core-kernel/src/bootstrap/app/load-namespace.ts → packages/core-kernel/src/bootstrap/app/register-base-namespace.ts

@@ -3,12 +3,12 @@ import { AbstractBootstrapper } from "../bootstrapper";
 
 /**
  * @export
- * @class LoadNamespace
+ * @class RegisterBaseNamespace
  */
-export class LoadNamespace extends AbstractBootstrapper {
+export class RegisterBaseNamespace extends AbstractBootstrapper {
     /**
      * @returns {Promise<void>}
-     * @memberof LoadNamespace
+     * @memberof RegisterBaseNamespace
      */
     public async bootstrap(): Promise<void> {
         const token: string = this.app.token();

packages/core-kernel/src/bootstrap/app/load-paths.ts → packages/core-kernel/src/bootstrap/app/register-base-paths.ts

@@ -8,12 +8,12 @@ import { AbstractBootstrapper } from "../bootstrapper";
 
 /**
  * @export
- * @class LoadPaths
+ * @class RegisterBasePaths
  */
-export class LoadPaths extends AbstractBootstrapper {
+export class RegisterBasePaths extends AbstractBootstrapper {
     /**
      * @returns {Promise<void>}
-     * @memberof LoadPaths
+     * @memberof RegisterBasePaths
      */
     public async bootstrap(): Promise<void> {
         const paths: Array<[string, string]> = Object.entries(envPaths(this.app.token(), { suffix: "core" }));

packages/core-kernel/src/bootstrap/app/register-base-service-providers.ts

@@ -0,0 +1,19 @@
+import { Config, Events } from "../../services";
+import { AbstractBootstrapper } from "../bootstrapper";
+
+/**
+ * @export
+ * @class RegisterBaseServiceProviders
+ */
+export class RegisterBaseServiceProviders extends AbstractBootstrapper {
+    /**
+     * @param {Kernel.IApplication} app
+     * @returns {Promise<void>}
+     * @memberof RegisterBaseServiceProviders
+     */
+    public async bootstrap(): Promise<void> {
+        await new Events.ServiceProvider(this.app).register();
+
+        await new Config.ServiceProvider(this.app).register();
+    }
+}

packages/core-kernel/src/bootstrap/app/load-error-handler.ts → packages/core-kernel/src/bootstrap/app/register-error-handler.ts

@@ -3,12 +3,12 @@ import { AbstractBootstrapper } from "../bootstrapper";
 
 /**
  * @export
- * @class LoadErrorHandler
+ * @class RegisterErrorHandler
  */
-export class LoadErrorHandler extends AbstractBootstrapper {
+export class RegisterErrorHandler extends AbstractBootstrapper {
     /**
      * @returns {Promise<void>}
-     * @memberof LoadErrorHandler
+     * @memberof RegisterErrorHandler
      */
     public async bootstrap(): Promise<void> {
         // @TODO: implement passing in of options and ensure handling of critical exceptions

packages/core-kernel/src/bootstrap/service-providers/boot-service-providers.ts

@@ -11,7 +11,7 @@ export class BootServiceProviders extends AbstractBootstrapper {
      * @memberof RegisterProviders
      */
     public async bootstrap(): Promise<void> {
-        const repository: ProviderRepository = this.app.resolve<ProviderRepository>("providers");
+        const repository: ProviderRepository = this.app.resolve<ProviderRepository>("service-providers");
 
         for (const [name] of repository.all()) {
             await repository.boot(name);

packages/core-kernel/src/bootstrap/service-providers/register-service-providers.ts

@@ -15,14 +15,14 @@ export class RegisterServiceProviders extends AbstractBootstrapper {
      * @memberof RegisterProviders
      */
     public async bootstrap(): Promise<void> {
-        const providers: ProviderRepository = this.app.resolve<ProviderRepository>("providers");
+        const serviceProviders: ProviderRepository = this.app.resolve<ProviderRepository>("service-providers");
 
-        for (const [name, serviceProvider] of providers.all()) {
+        for (const [name, serviceProvider] of serviceProviders.all()) {
             if (this.satisfiesDependencies(serviceProvider)) {
                 // @TODO: check conditional state and mark as either deferred or failed
                 // @TODO: check dependencies and either register or mark as failed
 
-                await providers.register(name);
+                await serviceProviders.register(name);
             }
         }
     }
@@ -34,7 +34,7 @@ export class RegisterServiceProviders extends AbstractBootstrapper {
      * @memberof RegisterProviders
      */
     private satisfiesDependencies(serviceProvider: AbstractServiceProvider): boolean {
-        const dependencies: Record<string, string> = serviceProvider.depends();
+        const dependencies: Record<string, string> = serviceProvider.getDependencies();
 
         if (!dependencies) {
             return true;