|
|
import { ActivationContext } from "./ActivationContext";
|
|
|
import { Descriptor, ActivationType, ServiceMap, isDescriptor } from "./interfaces";
|
|
|
import { Container } from "./Container";
|
|
|
import { argumentNotNull, isPrimitive } from "../safe";
|
|
|
import { TraceSource } from "../log/TraceSource";
|
|
|
|
|
|
let cacheId = 0;
|
|
|
|
|
|
const trace = TraceSource.get("@implab/core/di/ActivationContext");
|
|
|
|
|
|
function injectMethod(target, method, context, args) {
|
|
|
const m = target[method];
|
|
|
if (!m)
|
|
|
throw new Error("Method '" + method + "' not found");
|
|
|
|
|
|
if (args instanceof Array)
|
|
|
return m.apply(target, _parse(args, context, "." + method));
|
|
|
else
|
|
|
return m.call(target, _parse(args, context, "." + method));
|
|
|
}
|
|
|
|
|
|
function makeClenupCallback(target, method: ((instance) => void) | string) {
|
|
|
if (typeof (method) === "string") {
|
|
|
return () => {
|
|
|
target[method]();
|
|
|
};
|
|
|
} else {
|
|
|
return () => {
|
|
|
method(target);
|
|
|
};
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// TODO: make async
|
|
|
function _parse(value, context: ActivationContext, path: string) {
|
|
|
if (isPrimitive(value))
|
|
|
return value;
|
|
|
|
|
|
trace.debug("parse {0}", path);
|
|
|
|
|
|
if (isDescriptor(value))
|
|
|
return context.activate(value, path);
|
|
|
|
|
|
if (value instanceof Array)
|
|
|
return value.map((x, i) => _parse(x, context, `${path}[${i}]`));
|
|
|
|
|
|
const t = {};
|
|
|
for (const p of Object.keys(value))
|
|
|
t[p] = _parse(value[p], context, `${path}.${p}`);
|
|
|
|
|
|
return t;
|
|
|
}
|
|
|
|
|
|
export interface ServiceDescriptorParams {
|
|
|
activation?: ActivationType;
|
|
|
|
|
|
owner: Container;
|
|
|
|
|
|
params?;
|
|
|
|
|
|
inject?: object[];
|
|
|
|
|
|
services?: ServiceMap;
|
|
|
|
|
|
cleanup?: ((x) => void) | string;
|
|
|
}
|
|
|
|
|
|
export class ServiceDescriptor implements Descriptor {
|
|
|
_instance;
|
|
|
|
|
|
_hasInstance = false;
|
|
|
|
|
|
_activationType = ActivationType.Call;
|
|
|
|
|
|
_services: ServiceMap;
|
|
|
|
|
|
_params;
|
|
|
|
|
|
_inject: object[];
|
|
|
|
|
|
_cleanup: ((x) => void) | string;
|
|
|
|
|
|
_cacheId: any;
|
|
|
|
|
|
_owner: Container;
|
|
|
|
|
|
constructor(opts: ServiceDescriptorParams) {
|
|
|
argumentNotNull(opts, "opts");
|
|
|
argumentNotNull(opts.owner, "owner");
|
|
|
|
|
|
this._owner = opts.owner;
|
|
|
|
|
|
if ("activation" in opts)
|
|
|
this._activationType = opts.activation;
|
|
|
|
|
|
if ("params" in opts)
|
|
|
this._params = opts.params;
|
|
|
|
|
|
if (opts.inject)
|
|
|
this._inject = opts.inject;
|
|
|
|
|
|
if (opts.services)
|
|
|
this._services = opts.services;
|
|
|
|
|
|
if (opts.cleanup) {
|
|
|
if (!(typeof (opts.cleanup) === "string" || opts.cleanup instanceof Function))
|
|
|
throw new Error(
|
|
|
"The cleanup parameter must be either a function or a function name");
|
|
|
|
|
|
this._cleanup = opts.cleanup;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
activate(context: ActivationContext) {
|
|
|
// if we have a local service records, register them first
|
|
|
let instance;
|
|
|
|
|
|
// ensure we have a cache id
|
|
|
if (!this._cacheId)
|
|
|
this._cacheId = ++cacheId;
|
|
|
|
|
|
switch (this._activationType) {
|
|
|
case ActivationType.Singleton: // SINGLETON
|
|
|
// if the value is cached return it
|
|
|
if (this._hasInstance)
|
|
|
return this._instance;
|
|
|
|
|
|
// singletons are bound to the root container
|
|
|
const container = context.container.getRootContainer();
|
|
|
|
|
|
if (container.has(this._cacheId)) {
|
|
|
instance = container.get(this._cacheId);
|
|
|
} else {
|
|
|
instance = this._create(context);
|
|
|
container.store(this._cacheId, instance);
|
|
|
if (this._cleanup)
|
|
|
container.onDispose(
|
|
|
makeClenupCallback(instance, this._cleanup));
|
|
|
}
|
|
|
|
|
|
this._hasInstance = true;
|
|
|
return (this._instance = instance);
|
|
|
|
|
|
case ActivationType.Container: // CONTAINER
|
|
|
// return a cached value
|
|
|
|
|
|
if (this._hasInstance)
|
|
|
return this._instance;
|
|
|
|
|
|
// create an instance
|
|
|
instance = this._create(context);
|
|
|
|
|
|
// the instance is bound to the container
|
|
|
if (this._cleanup)
|
|
|
this._owner.onDispose(
|
|
|
makeClenupCallback(instance, this._cleanup));
|
|
|
|
|
|
// cache and return the instance
|
|
|
this._hasInstance = true;
|
|
|
return (this._instance = instance);
|
|
|
case ActivationType.Context: // CONTEXT
|
|
|
// return a cached value if one exists
|
|
|
|
|
|
if (context.has(this._cacheId))
|
|
|
return context.get(this._cacheId);
|
|
|
// context context activated instances are controlled by callers
|
|
|
return context.store(this._cacheId, this._create(context));
|
|
|
case ActivationType.Call: // CALL
|
|
|
// per-call created instances are controlled by callers
|
|
|
return this._create(context);
|
|
|
case ActivationType.Hierarchy: // HIERARCHY
|
|
|
// hierarchy activated instances are behave much like container activated
|
|
|
// except they are created and bound to the child container
|
|
|
|
|
|
// return a cached value
|
|
|
if (context.container.has(this._cacheId))
|
|
|
return context.container.get(this._cacheId);
|
|
|
|
|
|
instance = this._create(context);
|
|
|
|
|
|
if (this._cleanup)
|
|
|
context.container.onDispose(makeClenupCallback(
|
|
|
instance,
|
|
|
this._cleanup));
|
|
|
|
|
|
return context.container.store(this._cacheId, instance);
|
|
|
default:
|
|
|
throw new Error("Invalid activation type: " + this._activationType);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
isInstanceCreated() {
|
|
|
return this._hasInstance;
|
|
|
}
|
|
|
|
|
|
getInstance() {
|
|
|
return this._instance;
|
|
|
}
|
|
|
|
|
|
_factory(...params: any[]): any {
|
|
|
throw Error("Not implemented");
|
|
|
}
|
|
|
|
|
|
_create(context: ActivationContext) {
|
|
|
trace.debug(`constructing ${context._name}`);
|
|
|
|
|
|
if (this._activationType !== ActivationType.Call &&
|
|
|
context.visit(this._cacheId) > 0)
|
|
|
throw new Error("Recursion detected");
|
|
|
|
|
|
if (this._services) {
|
|
|
for (const p in this._services)
|
|
|
context.register(p, this._services[p]);
|
|
|
}
|
|
|
|
|
|
let instance;
|
|
|
|
|
|
if (this._params === undefined) {
|
|
|
instance = this._factory();
|
|
|
} else if (this._params instanceof Array) {
|
|
|
instance = this._factory.apply(this, _parse(this._params, context, "args"));
|
|
|
} else {
|
|
|
instance = this._factory(_parse(this._params, context, "args"));
|
|
|
}
|
|
|
|
|
|
if (this._inject) {
|
|
|
this._inject.forEach(spec => {
|
|
|
for (const m in spec)
|
|
|
injectMethod(instance, m, context, spec[m]);
|
|
|
});
|
|
|
}
|
|
|
return instance;
|
|
|
}
|
|
|
}
|
|
|
|
