return function (target: any) {
let currentMetadata: interfaces.ControllerMetadata = {
middleware: middleware,
path: path,
target: target
};
decorate(injectable(), target);
Reflect.defineMetadata(METADATA_KEY.controller, currentMetadata, target);
// We need to create an array that contains the metadata of all
// the controllers in the application, the metadata cannot be
// attached to a controller. It needs to be attached to a global
// We attach metadata to the Reflect object itself to avoid
// declaring additonal globals. Also, the Reflect is avaiable
// in both node and web browsers.
const previousMetadata: interfaces.ControllerMetadata[] = Reflect.getMetadata(
METADATA_KEY.controller,
Reflect
) || [];
const newMetadata = [currentMetadata, ...previousMetadata];
Reflect.defineMetadata(
METADATA_KEY.controller,
newMetadata,
Reflect
);
};
return function (target: any) {
const isAlreadyDecorated = Reflect.hasOwnMetadata(inversify_METADATA_KEY.PARAM_TYPES, target);
const redecorateWithInject = force === true;
if (redecorateWithInject === true && isAlreadyDecorated === false) {
decorate(injectable(), target);
} else if (redecorateWithInject === true && isAlreadyDecorated === true) {
// Do nothing
} else {
try {
decorate(injectable(), target);
} catch (e) {
throw new Error(
"Cannot apply @provide decorator multiple times but is has been used " +
`multiple times in ${target.name} ` +
"Please use @provide(ID, true) if you are trying to declare multiple bindings!"
);
}
}
const currentMetadata: interfaces.ProvideSyntax = {
constraint: (bind: inversifyInterfaces.Bind, bindTarget: any) => bind(serviceIdentifier).to(bindTarget),
implementationType: target
};
const previousMetadata: interfaces.ProvideSyntax[] = Reflect.getMetadata(
METADATA_KEY.provide,
Reflect
) || [];
const newMetadata = [currentMetadata, ...previousMetadata];
Reflect.defineMetadata(
METADATA_KEY.provide,
newMetadata,
Reflect
);
return target;
};
import { Container, interfaces, decorate, injectable } from 'inversify'
import { autoProvide, makeFluentProvideDecorator, makeProvideDecorator } from 'inversify-binding-decorators'
import { Controller } from 'tsoa'
const iocContainer = new Container()
const provide = makeProvideDecorator(iocContainer)
const fluentProvider = makeFluentProvideDecorator(iocContainer)
const provideNamed = (
identifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>,
name: string,
) => {
return fluentProvider(identifier)
.whenTargetNamed(name)
.done()
}
const provideSingleton = (
identifier: string | symbol | interfaces.Newable<any> | interfaces.Abstract<any>,
) => {
return fluentProvider(identifier)
.inSingletonScope()
.done()
}
// Needed to make controller injectable for extended Singleton class
decorate(injectable(), Controller)
export { iocContainer, autoProvide, provide, provideSingleton, provideNamed }
return function (target: any) {
decorate(injectable(), target);
Reflect.defineMetadata("prettygoat:method", method, target);
Reflect.defineMetadata("prettygoat:path", path, target);
return target;
};
} from './types';
import JsonConfigStore from './JsonConfigStore';
import QuoteAggregator from './QuoteAggregator';
import PositionService from './PositionService';
import BrokerAdapterRouter from './BrokerAdapterRouter';
import SpreadAnalyzer from './SpreadAnalyzer';
import ConfigValidator from './ConfigValidator';
import LimitCheckerFactory from './LimitCheckerFactory';
import { getActivePairStore } from './ActivePairLevelStore';
import { getChronoDB } from './chrono';
import OppotunitySearcher from './OpportunitySearcher';
import PairTrader from './PairTrader';
import SingleLegHandler from './SingleLegHandler';
import { EventEmitter } from 'events';
decorate(injectable(), EventEmitter);
const container = new Container();
container.bind<Arbitrager>(Arbitrager).toSelf();
container
.bind<ConfigStore>(symbols.ConfigStore)
.to(JsonConfigStore)
.inSingletonScope();
container
.bind<QuoteAggregator>(QuoteAggregator)
.toSelf()
.inSingletonScope();
container
.bind<PositionService>(PositionService)
.toSelf()
.inSingletonScope();
return function (target: any) {
decorate(injectable(), target);
Reflect.defineMetadata("ninjagoat:viewmodel", name, target);
return target;
};
export function InjectableDecorator(): ClassDecorator {
return inversify.injectable();
}