@shrub/core 0.5.26

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 jjvainav
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,151 @@
+# Description
+
+Shrub is a simple framework for building modular server-side applications and front-end components. The Core package provides a basic API for defining and loading modules.
+
+## Creating a Module
+
+A module can be defined as a class that implements the IModule interface or as a JSON object that satisfies the IModule interface.
+
+```typescript
+export class FooModule implements IModule {
+    readonly name = "foo";
+}
+```
+
+```typescript
+const fooModule: IModule = {
+    name: "foo"
+};
+```
+
+There are a few methods a module can define that allow it to configure functionality provided by the module and each method is invoked in the following order.
+
+### 1. `initialize(init: IModuleInitializer): void`
+
+Allows a module the ability to perform pre-initialization that needs to happen before any modules or services are configured. Such tasks include binding settings or registering a configuration interface that is exposed to other modules.
+
+### 2. `configureServices(registration: IServiceRegistration): void`
+
+Register services with a service collection.
+
+### 3. `configure(configurator: IModuleConfigurator): void | Promise<void>`
+
+Allows a module to perform additional configuration, such as configure a dependency module. This method supports async operations which can be useful if data needs to be fetched from a remote service during configuration.
+
+## Dependencies
+
+Module depenedencies are specified by defining a `dependencies` property on a module and lifecycle methods get invoked on the dependency before they are invoked on the dependent.
+
+```typescript
+export class FooModule implements IModule {
+    readonly name = "foo";
+    readonly dependencies = [BarModule];
+}
+```
+
+## Configuration
+
+```typescript
+export const IBarModuleConfiguration = createConfig<IBarModuleConfiguration>();
+export interface IBarModuleConfiguration {
+    registerWidget(widget: IWidget): void;
+}
+
+export class BarModule implements IModule {
+    readonly name = "bar";
+
+    initialize({ config }: IModuleInitializer): void {
+        config(IBarModuleConfiguration).register(() => ({
+            registerWidget: widget => {}
+        }));
+    }
+}
+
+export class FooModule implements IModule {
+    readonly name = "foo";
+    readonly dependencies = [BarModule];
+
+    configure({ config }: IModuleConfigurator): void {
+        config.get(IBarModuleConfiguration).registerWidget({});
+    }
+}
+```
+
+## Settings and Options
+
+While Dependency Configuration is a way for one module to configure another at load time. Settings provide a way to provide settings/configuration externally, such as from a config file.
+
+Module Settings are provided as a simple object keyed by a module's name; for example, the below is an example settings object that defines settings for the 'foo' module:
+
+```typescript
+const settings = {
+    foo: {
+        key: value
+    }
+};
+```
+
+A module can access these settings directly from the `configure` method:
+
+```typescript
+export class FooModule implements IModule {
+    readonly name = "foo";
+
+    configure({ settings }: IModuleConfigurator): void {
+        const keyValue = settings.key;
+    }
+}
+```
+
+Sometimes it's useful to pass settings to service instances and this can be done via Service Options.
+
+```typescript
+export const IFooOptions = createOptions<IFooOptions>("foo-options");
+export interface IFooOptions {
+    readonly value: string;
+}
+
+export class FooModule implements IModule {
+    readonly name = "foo";
+
+    initialize({ settings }: IModuleInitializer): void {
+        settings.bindToOptions(IFooOptions);
+    }
+
+    configureServices(registration: IServiceRegistration): void {
+        registration.registerTransient(IFooService, FooService);
+    }
+}
+
+export class FooService implements IFooService {
+    constructor(@IFooOptions private readonly options: IFooOptions) {
+    }
+}
+```
+
+## Loading Modules
+
+Modules are loaded using the `ModuleLoader` class by simply invoking `ModuleLoader.load`.
+
+```typescript
+await ModuleLoader.load([
+    FooModule,
+    BarModule
+]);
+```
+
+Note: If a module has any dependencies not specified when calling `ModuleLoader.load` those dependencies will automatically get loaded.
+
+If you want a little more control the module loader provides additional methods for configuring the service collection or settings.
+
+```typescript
+await ModuleLoader()
+    .useModules([
+        FooModule,
+        BarModule
+    ])
+    .useSettings({
+        foo: { value: "Hello!" }
+    })
+    .load();
+```

package/dist/esm/index.js

@@ -0,0 +1,3 @@
+export * from "./module";
+export * from "./service-collection";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxzQkFBc0IsQ0FBQyJ9

package/dist/esm/module.js

@@ -0,0 +1,247 @@
+import { ServiceMap } from "./service-collection";
+/** Creates a module configuration used to configure a module. */
+export function createConfig() {
+    return { key: Symbol() };
+}
+export class ModuleLoadError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ModuleLoadError.prototype);
+    }
+}
+/** Handles initializing and loading modules. */
+export class ModuleLoader {
+    constructor() {
+        this.services = new ServiceMap();
+        this.modules = [];
+        this.settings = {};
+    }
+    static load(modulesOrOptions) {
+        const options = Array.isArray(modulesOrOptions) ? { modules: modulesOrOptions } : modulesOrOptions;
+        const loader = new ModuleLoader();
+        if (options.settings) {
+            loader.useSettings(options.settings);
+        }
+        return loader.useModules(options.modules).load();
+    }
+    static configureServices(callback) {
+        return new ModuleLoader().configureServices(callback);
+    }
+    static useModules(modules) {
+        return new ModuleLoader().useModules(modules);
+    }
+    static useSettings(settings) {
+        return new ModuleLoader().useSettings(settings);
+    }
+    /**
+     * Loads the specified core modules into the manager. The load operation will discover
+     * the core module dependencies and then initialize/configure each module.
+     *
+     * This will first discover all dependent modules, create module instances, and sort the
+     * list of discovered modules by dependency (note: there is no guarantee of the order when creating
+     * module instances but each step against the discovered modules will execute against module dependents first).
+     *
+     * Module Steps:
+     *
+     * 1) Initialize
+     * 2) Configure Services
+     * 3) Configure
+     */
+    async load() {
+        this.ensureNotLoaded();
+        this.isLoaded = true;
+        // get all modules and sort by dependencies
+        const loadedModules = await this.expandAndSortModules();
+        // initialize discovered modules
+        const loader = this;
+        const configs = new Map();
+        loadedModules.forEach(module => {
+            if (module.initialize) {
+                module.initialize({
+                    config: type => ({
+                        register: callback => configs.set(type.key, { callback, module })
+                    }),
+                    get settings() {
+                        return {
+                            bindToOptions: (options, sectionName) => {
+                                loader.services.addOptionsProvider({
+                                    tryGet: (opt) => {
+                                        if (options === opt) {
+                                            const settings = loader.getSettingsForModule(module);
+                                            return sectionName ? settings[sectionName] : settings;
+                                        }
+                                        return undefined;
+                                    }
+                                });
+                            }
+                        };
+                    }
+                });
+            }
+        });
+        // configure the module services
+        for (const module of loadedModules) {
+            if (module.configureServices) {
+                module.configureServices(this.services);
+            }
+        }
+        this.services.freeze();
+        // lastly, configure the modules
+        const iterator = loadedModules[Symbol.iterator]();
+        const next = async () => {
+            for (const module of iterator) {
+                await configure(module);
+            }
+        };
+        const self = this;
+        const configure = (module) => module.configure && module.configure({
+            services: this.services,
+            settings: this.getSettingsForModule(module),
+            get options() {
+                return {
+                    get: (options) => self.services.getOptions(options)
+                };
+            },
+            get config() {
+                return {
+                    get: (type) => {
+                        const item = configs.get(type.key);
+                        if (!item) {
+                            throw new Error(`Config ${type.key.toString()} not found`);
+                        }
+                        return item.callback({
+                            ...this,
+                            // need to grab the module's settings that is being configured
+                            settings: loader.getSettingsForModule(item.module)
+                        });
+                    }
+                };
+            },
+            next
+        });
+        // invoke the iterator to start configuring the modules
+        return next().then(() => ({
+            services: this.services,
+            getInstance: (ctor) => {
+                const result = loadedModules.find(module => module instanceof ctor);
+                if (!result) {
+                    throw new Error("Module instance not found");
+                }
+                return result;
+            }
+        }));
+    }
+    configureServices(callback) {
+        this.ensureNotLoaded();
+        callback(this.services);
+        return this;
+    }
+    useModules(modules) {
+        this.ensureNotLoaded();
+        this.modules.push(...modules);
+        return this;
+    }
+    useSettings(settings) {
+        this.ensureNotLoaded();
+        this.settings = this.merge(settings, this.settings);
+        return this;
+    }
+    ensureNotLoaded() {
+        if (this.isLoaded) {
+            throw new Error("Modules have already been loaded.");
+        }
+    }
+    getSettingsForModule(module) {
+        return this.settings[module.name] || {};
+    }
+    async expandAndSortModules() {
+        const instances = new Map();
+        const sorted = [];
+        const visited = {};
+        const getInstance = async (dependency) => {
+            if (typeof dependency === "function") {
+                let instance = instances.get(dependency);
+                if (!instance) {
+                    try {
+                        instance = new dependency();
+                        if (instance.constructor === dependency) {
+                            // save the instance if the dependency is a constructor
+                            instances.set(dependency, instance);
+                        }
+                    }
+                    catch {
+                        // the dependency is a non-constructble function so invoke and assume the return will be a promise and use Promise.resolve to resolve it
+                        const instanceOrCtor = await Promise.resolve(dependency());
+                        instance = await getInstance(instanceOrCtor);
+                    }
+                }
+                // resolve incase the dependency is a function that returned a promise
+                return instance;
+            }
+            if (typeof dependency === "object") {
+                if (!this.isModule(dependency)) {
+                    throw new ModuleLoadError(`Object (${dependency.constructor.name}) is not a module.`);
+                }
+                const ctor = dependency.constructor;
+                if (ctor !== Object.prototype.constructor) {
+                    if (instances.has(ctor)) {
+                        throw new ModuleLoadError(`Duplicate module instances ${dependency.name}.`);
+                    }
+                    instances.set(ctor, dependency);
+                }
+                return dependency;
+            }
+            throw new ModuleLoadError(`Invalid dependency type (${typeof dependency}).`);
+        };
+        const visit = async (dependency, ancestors) => {
+            const module = await getInstance(dependency);
+            if (visited[module.name]) {
+                return;
+            }
+            if (!ancestors) {
+                ancestors = {};
+            }
+            if (ancestors[module.name]) {
+                throw new ModuleLoadError(`Circular dependency has been detected with module ${module.name}`);
+            }
+            ancestors[module.name] = true;
+            if (module.dependencies) {
+                for (const dependency of module.dependencies) {
+                    await visit(dependency, ancestors);
+                }
+            }
+            visited[module.name] = true;
+            // this performs a depth-first topological sort but instead of inserting
+            // to the front, push the module to the back of the list so that dependencies
+            // come first
+            sorted.push(module);
+        };
+        for (const module of this.modules) {
+            await visit(module);
+        }
+        return sorted;
+    }
+    merge(source, target) {
+        if (this.isObject(source) && this.isObject(target)) {
+            for (const key in source) {
+                if (source[key] === undefined) {
+                    // do not merge if the source value is undefined
+                    continue;
+                }
+                target = {
+                    ...target,
+                    [key]: this.isObject(source[key]) ? this.merge(source[key], target[key] || {}) : source[key]
+                };
+            }
+        }
+        return target;
+    }
+    isObject(obj) {
+        return typeof obj === "object" && !Array.isArray(obj);
+    }
+    isModule(obj) {
+        // a module only requires a name so that's all we can really check for
+        return typeof obj === "object" && obj.name !== undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module.js","sourceRoot":"","sources":["../../src/module.ts"],"names":[],"mappings":"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"}