@alterior/runtime 3.5.2 → 3.5.5

package/src/reflector.ts

@@ -0,0 +1,433 @@
+import { Annotation, Annotations, IAnnotation } from "@alterior/annotations";
+import { getParameterNames } from "@alterior/common";
+
+export interface Constructor<T> {
+    new(...args) : T;
+}
+
+export type Visibility = 'private' | 'public' | 'protected';
+
+/**
+ * Represents a property on a class. A property can also be a field or a method.
+ */
+export class Property<T>{
+    constructor(
+        private _type : Constructor<T>,
+        private _name : string,
+        private _isStatic : boolean = false
+    ) {
+        this._visibility = _name[0] === '_' ? 'private' : 'public';
+    }
+
+    private _visibility : Visibility;
+    private _descriptor : PropertyDescriptor = null;
+    private _annotations : IAnnotation[];
+
+    defineMetadata(key : string, value : string) {
+        Reflect.defineMetadata(key, value, this.type, this.name);
+    }
+
+    getMetadata(key : string): any {
+        return Reflect.getMetadata(key, this.type, this.name);
+    }
+
+    deleteMetadata(key : string) {
+        Reflect.deleteMetadata(key, this.type, this.name);
+    }
+
+    private _valueType : Type<any>;
+    get valueType() : Type<any> {
+        if (!this._valueType) {
+            let rawType = this.getMetadata('design:type');
+            if (!rawType)
+                return undefined;
+            this._valueType = new Type<any>(rawType);    
+        }
+
+        return this._valueType;
+    }
+
+    public get isStatic() {
+        return this._isStatic;
+    }
+
+    protected get type() {
+        return this._type;
+    }
+
+    get annotations() {
+        if (!this._annotations) {
+            if (this._name === 'constructor')
+                this._annotations = Annotations.getClassAnnotations(this._type);
+            else
+                this._annotations = Annotations.getPropertyAnnotations(this._type, this.name, this.isStatic);
+        }
+
+        return this._annotations;
+    }
+
+    annotationsOfType<T extends Annotation>(type : Constructor<T>) : T[] {
+        return (type as any).filter(this.annotations);
+    }
+
+    annotationOfType<T extends Annotation>(type : Constructor<T>) : T {
+        return (type as any).filter(this.annotations)[0];
+    }
+
+    get descriptor() : PropertyDescriptor {
+        if (!this._descriptor)
+            this._descriptor = Object.getOwnPropertyDescriptor(this._type.prototype, this._name);
+
+        return this._descriptor;
+    }
+
+    get name() {
+        return this._name;
+    }
+
+    get visibility() {
+        return this._visibility;
+    }
+}
+
+/**
+ * Represents a method on a class. A method can be a static or instance method, and has a set of parameters 
+ * and a return type.
+ */
+export class Method<T> extends Property<T> {
+    constructor(
+        type : Constructor<T>,
+        name : string,
+        isStatic : boolean = false
+    ) {
+        super(type, name, isStatic);
+    }
+
+    private _parameterNames : string[];
+    private _implementation : Function;
+
+    private _returnType : Type<any>;
+    get returnType() : Type<any> {
+        if (!this._returnType) {
+            let rawType = this.getMetadata('design:returntype');
+            if (!rawType)
+                return undefined;
+            this._returnType = new Type<any>(rawType);    
+        }
+
+        return this._returnType;
+    }
+
+    private _parameterTypes : Type<any>;
+    get parameterTypes() : Type<any> {
+        if (!this._parameterTypes) {
+            let rawTypes = this.getMetadata('design:paramtypes');
+            this._parameterTypes = rawTypes.map(x => x ? new Type<any>(x) : undefined);
+        }
+
+        return this._parameterTypes;
+    }
+
+    get implementation() : Function {
+        return this.type[this.name];
+    }
+
+    get parameterNames() {
+        if (!this._parameterNames)
+            this._parameterNames = getParameterNames(this.implementation);
+
+        return this._parameterNames;
+    }
+
+    get parameters(): Parameter<T>[] {
+        let parameterNames = this.parameterNames;
+        return [...Array(this.implementation.length).keys()]
+            .map(i => new Parameter(this, i, parameterNames[i]))
+        ;
+    }
+
+    private _parameterAnnotations : IAnnotation[][];
+
+    get parameterAnnotations(): IAnnotation[][] {
+        if (!this._parameterAnnotations)
+            this._parameterAnnotations = Annotations.getParameterAnnotations(this.type, this.name);
+
+        return this._parameterAnnotations;
+    }
+}
+
+export class Field<T> extends Property<T> {
+    constructor(
+        type : Constructor<T>,
+        name : string,
+        isStatic : boolean = false
+    ) {
+        super(type, name, isStatic);
+    }
+}
+
+export class ConstructorMethod<T> extends Method<T> {
+    constructor(
+        type : Constructor<T>
+    ) {
+        super(type, 'constructor');
+    }
+
+    private _ctorParameterAnnotations : IAnnotation[][];
+    get parameterAnnotations() {
+        if (!this._ctorParameterAnnotations)
+            this._ctorParameterAnnotations = Annotations.getConstructorParameterAnnotations(this.type);
+
+        return this._ctorParameterAnnotations;
+    }
+}
+
+export class Parameter<T> {
+    constructor(
+        private _method : Method<T>,
+        private _index : number,
+        private _name : string = null
+    ) {
+    
+    }
+
+    private _annotations : Annotation[];
+
+    get annotations() {
+        return this.method.parameterAnnotations[this.index];
+    }
+
+    annotationsOfType<T extends Annotation>(type : Constructor<T>) : T[] {
+        return (type as any).filter(this.annotations);
+    }
+
+    annotationOfType<T extends Annotation>(type : Constructor<T>) : T {
+        return (type as any).filter(this.annotations)[0];
+    }
+
+    protected get method() {
+        return this._method;
+    }
+
+    get valueType() {
+        return this.method.parameterTypes[this.index];
+    }
+
+    get index() {
+        return this._index;
+    }
+
+    get name() {
+        return this._name;
+    }
+}
+
+/**
+ * Represents a class Type and it's metadata
+ */
+export class Type<T extends Object> {
+    constructor(
+        private _class : Constructor<T>
+    ) {
+    }
+
+    private _propertyNames : string[];
+    private _methodNames : string[];
+    private _fieldNames : string[];
+    private _annotations : IAnnotation[];
+
+    get name() {
+        return this._class.name;
+    }
+
+    getMetadata(key : string) {
+        Reflect.getOwnMetadata(key, this._class);
+    }
+
+    defineMetadata(key : string, value : any) {
+        Reflect.defineMetadata(key, value, this._class.prototype);
+    }
+
+    deleteMetadata(key : string) {
+        Reflect.deleteMetadata(key, this._class);
+    }
+
+    private _metadataKeys : string[];
+    get metadataKeys() : string[] {
+        if (!this._metadataKeys)
+            this._metadataKeys = Reflect.getOwnMetadataKeys(this._class);
+     
+        return this._metadataKeys;
+    }
+
+    /**
+     * Get all annotations attached to this class
+     */
+    get annotations(): IAnnotation[] {
+        if (!this._annotations)
+            this._annotations = Annotations.getClassAnnotations(this._class);
+
+        return this._annotations;
+    }
+
+    annotationsOfType<T extends Annotation>(type : Constructor<T>) : T[] {
+        return (type as any).filter(this.annotations);
+    }
+
+    annotationOfType<T extends Annotation>(type : Constructor<T>) : T {
+        return (type as any).filter(this.annotations)[0];
+    }
+
+    private fetchPropertyNames() {
+        this._propertyNames = Object.getOwnPropertyNames(this._class.prototype);
+        for (let propertyName of this._propertyNames) {
+            if (typeof this._class.prototype[propertyName] === 'function') {
+                this._methodNames.push(propertyName);
+            } else {
+                this._fieldNames.push(propertyName);
+            }
+        }
+    }
+
+    private _staticPropertyNames : string[] = [];
+    private _staticMethodNames : string[] = [];
+    private _staticFieldNames : string[] = [];
+
+    private fetchStaticPropertyNames() {
+        this._staticPropertyNames = Object.getOwnPropertyNames(this._class).filter(x => !['length', 'prototype', 'name'].includes(x));
+        
+        for (let propertyName of this._staticPropertyNames) {
+            if (typeof this._class[propertyName] === 'function') {
+                this._staticMethodNames.push(propertyName);
+            } else {
+                this._staticFieldNames.push(propertyName);
+            }
+        }
+    }
+
+    get staticPropertyNames() {
+        if (!this._staticPropertyNames)
+            this.fetchStaticPropertyNames();
+
+        return this._staticPropertyNames.slice();
+    }
+
+    get staticMethodNames() {
+        if (!this._staticPropertyNames)
+            this.fetchStaticPropertyNames();
+
+        return this._staticMethodNames.slice();
+    }
+
+    get staticFieldNames() {
+        if (!this._staticPropertyNames)
+            this.fetchStaticPropertyNames();
+
+        return this._staticFieldNames.slice();
+    }
+
+    private _staticMethods : Method<T>[];
+    get staticMethods() : Method<T>[] {
+        if (this._staticMethods)
+            return this._staticMethods;
+
+        this._staticMethods = this.staticMethodNames.map(methodName => new Method<T>(this._class, methodName, true));
+
+        return this._staticMethods;
+    }
+
+    private _staticFields : Field<T>[];
+    get staticFields() : Field<T>[] {
+        if (this._staticFields)
+            return this._staticFields;
+
+        this._staticFields = this.staticFieldNames.map(fieldName => new Field<T>(this._class, fieldName, true));
+
+        return this._staticFields;
+    }
+
+    private _staticProperties : Property<T>[];
+    get staticProperties() {
+        if (this._staticProperties)
+            return this._staticProperties;
+
+        this._staticProperties = [].concat(this.staticFields, this.staticMethods);
+
+        return this._staticProperties;
+    }
+
+    get propertyNames() {
+        if (!this._propertyNames)
+            this.fetchPropertyNames();
+
+        return this._propertyNames.slice();
+    }
+
+    get methodNames() {
+        if (!this._propertyNames)
+            this.fetchPropertyNames();
+
+        return this._methodNames.slice();
+    }
+
+    get fieldNames() {
+        if (!this._propertyNames)
+            this.fetchPropertyNames();
+
+        return this._fieldNames.slice();
+    }
+
+    private _ctor : ConstructorMethod<T>;
+    get constructorMethod() {
+        if (!this._ctor)
+            this._ctor = new ConstructorMethod<T>(this._class);
+
+        return this._ctor;
+    }
+
+    private _methods : Method<T>[];
+    get methods() {
+        if (this._methods)
+            return this._methods;
+
+        this._methods = this.methodNames.map(methodName => new Method<T>(this._class, methodName));
+
+        return this._methods;
+    }
+
+    private _properties : Property<T>[];
+
+    get properties() {
+        if (this._properties)
+            return this._properties;
+
+        this._properties = [].concat(this.fields, this.methods);
+
+        return this._properties;
+    }
+
+    private _fields : Field<T>[];
+
+    get fields() {
+        if (this._fields)
+            return this._fields;
+
+        this._fields = this.fieldNames.map(fieldName => new Field<T>(this._class, fieldName));
+
+        return this._fields;
+    }
+
+    get base(): Type<any> {
+        return new Type<any>(Object.getPrototypeOf(this._class));
+    }
+}
+
+export class Reflector {
+    getTypeFromInstance<T extends Object = any>(instance : T) : Type<T> {
+        return this.getTypeFromClass<T>(instance.constructor as any);
+    }
+
+    getTypeFromClass<T = any>(typeClass : Constructor<T>): Type<T> {
+        return new Type(typeClass);
+    }
+}

package/src/roles.service.ts

@@ -0,0 +1,171 @@
+import { Injectable } from "@alterior/di";
+import { timeout, InvalidOperationError, ArgumentError } from "@alterior/common";
+
+const SUPPORTED_ROLE_MODES =       ['all-except',  'only' ];
+export type RoleConfigurationMode = 'all-except' | 'only'  ;
+
+export interface RoleConfiguration {
+    mode : RoleConfigurationMode;
+    roles : any[];
+}
+
+/**
+ * Role registration information. Use this when your module provides a service which should support being turned on and 
+ * off at runtime.
+ */
+export interface RoleRegistration {
+    /**
+     * The instance of the module being registered. This should be `this` for the caller in most cases, as it should be 
+     * called from an Alterior module's `altOnInit()` method.
+     */
+    instance : any;
+    
+    /**
+     * The identifier that will be matched when interpreting command line role enablements.
+     */
+    identifier : string;
+
+    /**
+     * The human readable name for this role. 
+     */
+    name : string;
+
+    /**
+     * A short (one sentence) summary which may be shown in command line help output and other places.
+     */
+    summary : string;
+
+    /**
+     * Start services associated with this role. 
+     * For instance, an HTTP server module would start it's HTTP server.
+     */
+    start() : Promise<void>;
+
+    /**
+     * Stop services associated with this role.
+     */
+    stop() : Promise<void>;
+}
+
+export interface RoleState extends RoleRegistration {
+    class : any;
+    running : boolean;
+}
+
+/**
+ * Roles allow runtime configuration of which outward facing services to start. 
+ * For instance WebServerModule and TasksModule both register their respective roles, 
+ * so that they can be easily turned on and off when the application is called.
+ * 
+ */
+@Injectable()
+export class RolesService {
+    constructor() {
+
+    }
+
+    _activeRoles : any[] = null;
+    _configuration : RoleConfiguration = { mode: 'all-except', roles: [] };
+    _roles : RoleState[] = [];
+
+    get configuration() : RoleConfiguration {
+        return this._configuration;
+    }
+
+    /**
+     * Register a role which can be managed by this service.
+     */
+    registerRole(role : RoleRegistration) {
+        let roleState : RoleState = Object.assign(
+            role,
+            {
+                class: role.instance.constructor,
+                running: false
+            }
+        );
+
+        this._roles.push(roleState);
+    }
+
+    get roles(): RoleState[] {
+        return this._roles;
+    }
+
+    /**
+     * Calculate the exact list of roles the configuration currently applies to.
+     */
+    get effectiveRoles(): RoleState[] {
+        let config = this._configuration;
+
+        if (config.mode == 'all-except')
+            return this._roles.filter(x => !config.roles.includes(x.class));
+        else if (config.mode == 'only')
+            return this._roles.filter(x => config.roles.includes(x.class));
+        
+        return [];
+    }
+
+    get activeRoles(): RoleState[] {
+        return this._roles.filter(x => x.running);
+    }
+
+    /**
+     * Configure which roles should be run by this service
+     */
+    configure(config : RoleConfiguration) {
+        if (!SUPPORTED_ROLE_MODES.includes(config.mode))
+            throw new InvalidOperationError(`Role mode '${config.mode}' is not supported (supports 'all-except', 'only')`);
+        
+        this._configuration = config;
+    }
+
+    getForModule(roleModuleClass) {
+        let role = this._roles.find(x => x.class === roleModuleClass);
+
+        if (!role)
+            throw new ArgumentError(`Role module class ${roleModuleClass.name} is not registered`);
+
+        return role;
+    }
+
+    getById(id : string) {
+        let role = this._roles.find(x => x.identifier === id);
+
+        if (!role)
+            throw new ArgumentError(`Role with ID '${id}' is not registered`);
+
+        return role;
+    }
+
+    async restartAll() {
+        await this.stopAll();
+        await timeout(1);
+        await this.startAll();
+    }
+
+    silent = false;
+
+    async startAll() {
+        await Promise.all(
+            this.effectiveRoles
+                .filter(role => !role.running)
+                .map(async role => {
+                    await role.start();
+                    if (!this.silent)
+                        console.log(`** [${role.identifier}] Started`);
+                })
+        );
+    }
+
+    async stopAll() {
+
+        await Promise.all(
+            this.activeRoles
+                .map(async role => {
+                    await role.stop();
+                    if (!this.silent)
+                        console.log(`** [${role.identifier}] Stopped`);
+                })
+        );
+    }
+}

package/src/service.ts

@@ -0,0 +1,34 @@
+import { MetadataName, Annotation } from '@alterior/annotations';
+import { Type } from '@alterior/di';
+
+export interface MethodShimParam {
+    name : string;
+    type : Type;
+    default? : any;
+}
+
+export interface MethodShim {
+    name : string;
+    params : MethodShimParam[];
+    target : Type;
+    body : string;
+}
+
+export abstract class ServiceCompiler {
+    abstract compileMethod(method : MethodShim) : void;
+}
+
+export interface ServiceOptions {
+    compiler: Type<ServiceCompiler>;
+}
+
+@MetadataName('@alterior/runtime:Service')
+export class ServiceAnnotation extends Annotation implements ServiceOptions {
+    constructor(options? : ServiceOptions) {
+        super(options);
+    }
+
+    compiler : Type<ServiceCompiler>;
+}
+
+export const Service = ServiceAnnotation.decorator();