@shrub/core 0.5.26

package/dist/module.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModuleLoader = exports.ModuleLoadError = exports.createConfig = void 0;
+const service_collection_1 = require("./service-collection");
+/** Creates a module configuration used to configure a module. */
+function createConfig() {
+    return { key: Symbol() };
+}
+exports.createConfig = createConfig;
+class ModuleLoadError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, ModuleLoadError.prototype);
+    }
+}
+exports.ModuleLoadError = ModuleLoadError;
+/** Handles initializing and loading modules. */
+class ModuleLoader {
+    constructor() {
+        this.services = new service_collection_1.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;
+    }
+}
+exports.ModuleLoader = ModuleLoader;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"module.js","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"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"}

package/dist/service-collection.d.ts

@@ -0,0 +1,146 @@
+export declare type ValidateOptionsCallback<T> = (obj: T, invalid: (err: OptionsValidationError) => void) => void;
+export declare type ValidateOptionsFailCallback = (err: OptionsValidationError) => void;
+declare type Constructor<T> = {
+    new (...args: any[]): T;
+};
+declare type NonOptionalKeys<T> = {
+    [K in keyof T]-?: undefined extends T[K] ? never : K;
+}[keyof T];
+/** Defines an object that supports a dispose function; scoped service instances that implement dispose will get invoked when the scoped container is cleaned up. */
+export interface IDisposable {
+    dispose(): void;
+}
+export interface IInjectable<T> {
+    readonly key: string;
+    readonly factory?: (services: IServiceCollection) => T;
+    (...args: any[]): void;
+}
+export interface IInjectableOptions<T> {
+    readonly key: string;
+    readonly factory?: (services: IServiceCollection) => T;
+}
+export interface IOptions<T> extends IInjectable<T> {
+    readonly defaultOptions?: T;
+    readonly register: (callback: ValidateOptionsCallback<T>) => void;
+    readonly require: (...props: NonOptionalKeys<T>[]) => void;
+    readonly validate: (obj: T, fail: ValidateOptionsFailCallback) => boolean;
+}
+export interface IService<T> extends IInjectable<T> {
+}
+export interface IInstantiationService {
+    createInstance<T>(ctor: Constructor<T>): T;
+}
+export interface IOptionsService {
+    /** Adds an options provider to the service. */
+    addOptionsProvider(provider: IOptionsProvider): void;
+    /** Registers a callback that gets invoked to configure/modify an options instance when one has been requested. */
+    configureOptions<T>(options: IOptions<T>, callback: (options: T) => T): void;
+    /** Gets an instance of the specified options. */
+    getOptions<T>(options: IOptions<T>): T;
+}
+export interface IOptionsProvider {
+    tryGet<T>(id: IOptions<T>): T | undefined;
+}
+export interface IServiceRegistration {
+    /** Registers a service using its required scope. Note: a service class must define a required scope decorator. */
+    register<T, TInstance extends T>(service: IService<T>, ctor: Constructor<TInstance>): void;
+    /** Registers a singleton instance that lives within the collection and is available to all child scopes. Note: if the instance implements IDisposable it will not be disposed automatically. */
+    registerInstance<T, TInstance extends T>(service: IService<T>, instance: TInstance): void;
+    /** Registers a service that gets created once per service collection scope. */
+    registerScoped<T, TInstance extends T>(service: IService<T>, ctorOrFactory: Constructor<TInstance> | IServiceFactory<TInstance>): void;
+    /** Registers a service that gets created once and is available to all child scopes. */
+    registerSingleton<T, TInstance extends T>(service: IService<T>, ctorOrFactory: Constructor<TInstance> | IServiceFactory<TInstance>): void;
+    /** Registers a service that gets created each time the service is requested from a collection. */
+    registerTransient<T, TInstance extends T>(service: IService<T>, ctorOrFactory: Constructor<TInstance> | IServiceFactory<TInstance>): void;
+    /** Attempts to register a service using its required scope but only if a service has not already been registered. Note: a service class must define a required scope decorator. */
+    tryRegister<T, TInstance extends T>(service: IService<T>, ctor: Constructor<TInstance>): boolean;
+    /** Attempts to register a singleton instance that lives within the collection and is available to all child scopes. Note: if the instance implements IDisposable it will not be disposed automatically. */
+    tryRegisterInstance<T, TInstance extends T>(service: IService<T>, instance: TInstance): boolean;
+    /** Attempts to register a service that gets created once per service collection scope. */
+    tryRegisterScoped<T, TInstance extends T>(service: IService<T>, ctorOrFactory: Constructor<TInstance> | IServiceFactory<TInstance>): boolean;
+    /** Attempts to register a service that gets created once and is available to all child scopes. */
+    tryRegisterSingleton<T, TInstance extends T>(service: IService<T>, ctorOrFactory: Constructor<TInstance> | IServiceFactory<TInstance>): boolean;
+    /** Attempts to register a service that gets created each time the service is requested from a collection. */
+    tryRegisterTransient<T, TInstance extends T>(service: IService<T>, ctorOrFactory: Constructor<TInstance> | IServiceFactory<TInstance>): boolean;
+}
+export interface IServiceCollection {
+    /** Creates a scoped collection. */
+    createScope(): IScopedServiceCollection;
+    /** Gets an instance of the registered service. */
+    get<T>(serviceOrKey: IService<T> | string): T;
+    /** True if a service has been registered. */
+    has<T>(serviceOrKey: IService<T> | string): boolean;
+    /** Gets an instance of the specified service if one has been registered or undefined if not. */
+    tryGet<T>(serviceOrKey: IService<T> | string): T | undefined;
+}
+export interface IServiceFactory<T> {
+    create(services: IServiceCollection): T;
+}
+export interface IScopedServiceCollection extends IServiceCollection, IDisposable {
+}
+export declare const IInstantiationService: IService<IInstantiationService>;
+export declare const IOptionsService: IService<IOptionsService>;
+export declare const IServiceCollection: IService<IServiceCollection>;
+/** Class decorator identifying the required scope for a service as 'scoped'. */
+export declare function Scoped(ctor: any): void;
+/** Class decorator identifying the required scope for a service as 'singleton'. */
+export declare function Singleton(ctor: any): void;
+/** Class decorator identifying the required scope for a service as 'transient'. */
+export declare function Transient(ctor: any): void;
+export declare function createInjectable<T>(key: string): IInjectable<T>;
+export declare function createInjectable<T>(options: IInjectableOptions<T>): IInjectable<T>;
+export declare function createOptions<T>(key: string, defaultOptions?: T): IOptions<T>;
+export declare function createService<T>(key: string): IService<T>;
+/** Represents an error that has occurred while trying to create an object instance. */
+export declare class ObjectCreateError extends Error {
+    readonly inner: Error;
+    constructor(message: string, inner: Error);
+}
+/**
+ *  A service factory that will create a single instance and return the same instance everytime create is invoked.
+ *  This is useful for singleton services that implement multiple service interfaces.
+ */
+export declare class SingletonServiceFactory<T> implements IServiceFactory<T> {
+    private readonly ctorOrFactory;
+    private instance?;
+    constructor(ctorOrFactory: Constructor<T> | IServiceFactory<T>);
+    create(services: IServiceCollection): T;
+}
+export declare class ServiceMap implements IServiceRegistration, IServiceCollection, IOptionsService, IInstantiationService {
+    private readonly services;
+    private isFrozen?;
+    constructor();
+    addOptionsProvider(provider: IOptionsProvider): void;
+    configureOptions<T>(options: IOptions<T>, callback: (options: T) => T): void;
+    createInstance<T>(ctor: Constructor<T>): T;
+    createScope(): IScopedServiceCollection;
+    getOptions<T>(options: IOptions<T>): T;
+    register<T, TInstance extends T>(service: IService<T>, ctor: Constructor<TInstance>): void;
+    registerInstance<T, TInstance extends T>(service: IService<T>, instance: TInstance): void;
+    registerScoped<T, TInstance extends T>(service: IService<T>, ctorOrFactory: Constructor<TInstance> | IServiceFactory<TInstance>): void;
+    registerSingleton<T, TInstance extends T>(service: IService<T>, ctorOrFactory: Constructor<TInstance> | IServiceFactory<TInstance>): void;
+    registerTransient<T, TInstance extends T>(service: IService<T>, ctorOrFactory: Constructor<TInstance> | IServiceFactory<TInstance>): void;
+    tryRegister<T, TInstance extends T>(service: IService<T>, ctor: Constructor<TInstance>): boolean;
+    tryRegisterInstance<T, TInstance extends T>(service: IService<T>, instance: TInstance): boolean;
+    tryRegisterScoped<T, TInstance extends T>(service: IService<T>, ctorOrFactory: Constructor<TInstance> | IServiceFactory<TInstance>): boolean;
+    tryRegisterSingleton<T, TInstance extends T>(service: IService<T>, ctorOrFactory: Constructor<TInstance> | IServiceFactory<TInstance>): boolean;
+    tryRegisterTransient<T, TInstance extends T>(service: IService<T>, ctorOrFactory: Constructor<TInstance> | IServiceFactory<TInstance>): boolean;
+    get<T>(serviceOrKey: IService<T> | string): T;
+    has<T>(serviceOrKey: IService<T> | string): boolean;
+    tryGet<T>(serviceOrKey: IService<T> | string): T | undefined;
+    /** Prevents items from being registered with the serivce map. */
+    freeze(): void;
+    private registerService;
+    private registerEntry;
+    private checkFactoryInstance;
+    private checkInstanceScope;
+    private getOrCreateServiceInstance;
+    private getOrCreateInjectable;
+    private createServiceInstance;
+    private createObjectInstance;
+}
+/** Represents an error for an options object instance that failed validation. */
+export declare class OptionsValidationError extends Error {
+    constructor(message: string);
+}
+export {};