@nodeswork/kiws/dist/injection.d.ts

Koa-based Injectable Web Service

import 'reflect-metadata';
export declare const INJECTION_METADATA_KEY: symbol;
export declare type Constructor = {
    new (...args: any[]): {};
};
export interface ConstructorOverride {
    provide: string;
    useClass: Constructor | Constructor[];
    multi?: boolean;
}
export declare type Beans = {
    [key: string]: Constructor[];
};
export declare type Singletons = {
    [key: string]: any[];
};
/**
 * Bean provider to hold injection instances and create beans.
 */
export declare class BeanProvider {
    private beans;
    private singletons;
    /**
     * Register a new constructor.
     */
    register(val: Constructor | ConstructorOverride): void;
    getBean<T>(key: string, inputs?: any[]): T;
    getBeans<T>(key: string, inputs?: any[], options?: {
        limit?: number;
    }): T[];
    getSingletonBean<T>(key: string): T;
    getSingletonBeans<T>(key: string): T[];
    getRegisteredBeans(): Constructor[];
    getRegisteredBeanClazz(): Beans;
    clear(): void;
}
export declare const beanProvider: BeanProvider;
export interface InjectMetadata {
    ref: string;
    isArray: boolean;
}
export interface InputMetadata extends InjectMetadata {
    propertyName: string;
    fallback: boolean;
}
export interface InjectionMetadata {
    name?: string;
    tags?: string[];
    meta?: any;
    posts?: string[];
    injects?: InjectMetadata[];
    inputs?: InputMetadata[];
}
/**
 * Property decorator which will be injected from inputs or registerd
 * constructors.
 */
export declare function Inject(options?: {
    type?: string;
}): (target: any, propertyName: string) => void;
/**
 * Property decorator which will be injected from inputs only.
 */
export declare function Input(options?: {
    type?: string;
    fallback?: boolean;
}): (target: any, propertyName: string) => void;
/**
 * Decorator for methods which will be executed after construtor.
 */
export declare function PostConstruct(): (target: any, propertyName: string, descriptor: PropertyDescriptor) => void;
export interface InjectableOptions {
    inputs?: boolean;
    tags?: string[];
    meta?: object;
}
export declare function Token(name: string): (target: Object, propertyKey: string, parameterIndex: number) => void;
/**
 * Class decorator to specify tags and metas associated with the constructor.
 */
export declare function Injectable(options?: InjectableOptions): <T extends new (...args: any[]) => {}>(constructor: T) => void;
export declare function getInjectionMetadata(constructor: Constructor): InjectionMetadata;
export declare function defineInjectionMetadata(constructor: Constructor, metadata: InjectionMetadata): void;