1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var binding_count_1 = require("../bindings/binding_count");
var ERROR_MSGS = require("../constants/error_msgs");
var literal_types_1 = require("../constants/literal_types");
var METADATA_KEY = require("../constants/metadata_keys");
var exceptions_1 = require("../utils/exceptions");
var serialization_1 = require("../utils/serialization");
var context_1 = require("./context");
var metadata_1 = require("./metadata");
var plan_1 = require("./plan");
var reflection_utils_1 = require("./reflection_utils");
var request_1 = require("./request");
var target_1 = require("./target");
function getBindingDictionary(cntnr) {
return cntnr._bindingDictionary;
}
exports.getBindingDictionary = getBindingDictionary;
function _createTarget(isMultiInject, targetType, serviceIdentifier, name, key, value) {
var metadataKey = isMultiInject ? METADATA_KEY.MULTI_INJECT_TAG : METADATA_KEY.INJECT_TAG;
var injectMetadata = new metadata_1.Metadata(metadataKey, serviceIdentifier);
var target = new target_1.Target(targetType, name, serviceIdentifier, injectMetadata);
if (key !== undefined) {
var tagMetadata = new metadata_1.Metadata(key, value);
target.metadata.push(tagMetadata);
}
return target;
}
function _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target) {
var bindings = getBindings(context.container, target.serviceIdentifier);
var activeBindings = [];
if (bindings.length === binding_count_1.BindingCount.NoBindingsAvailable &&
context.container.options.autoBindInjectable &&
typeof target.serviceIdentifier === "function" &&
metadataReader.getConstructorMetadata(target.serviceIdentifier).compilerGeneratedMetadata) {
context.container.bind(target.serviceIdentifier).toSelf();
bindings = getBindings(context.container, target.serviceIdentifier);
}
if (!avoidConstraints) {
activeBindings = bindings.filter(function (binding) {
var request = new request_1.Request(binding.serviceIdentifier, context, parentRequest, binding, target);
return binding.constraint(request);
});
}
else {
activeBindings = bindings;
}
_validateActiveBindingCount(target.serviceIdentifier, activeBindings, target, context.container);
return activeBindings;
}
function _validateActiveBindingCount(serviceIdentifier, bindings, target, container) {
switch (bindings.length) {
case binding_count_1.BindingCount.NoBindingsAvailable:
if (target.isOptional()) {
return bindings;
}
else {
var serviceIdentifierString = serialization_1.getServiceIdentifierAsString(serviceIdentifier);
var msg = ERROR_MSGS.NOT_REGISTERED;
msg += serialization_1.listMetadataForTarget(serviceIdentifierString, target);
msg += serialization_1.listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);
throw new Error(msg);
}
case binding_count_1.BindingCount.OnlyOneBindingAvailable:
if (!target.isArray()) {
return bindings;
}
case binding_count_1.BindingCount.MultipleBindingsAvailable:
default:
if (!target.isArray()) {
var serviceIdentifierString = serialization_1.getServiceIdentifierAsString(serviceIdentifier);
var msg = ERROR_MSGS.AMBIGUOUS_MATCH + " " + serviceIdentifierString;
msg += serialization_1.listRegisteredBindingsForServiceIdentifier(container, serviceIdentifierString, getBindings);
throw new Error(msg);
}
else {
return bindings;
}
}
}
function _createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, parentRequest, target) {
var activeBindings;
var childRequest;
if (parentRequest === null) {
activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, null, target);
childRequest = new request_1.Request(serviceIdentifier, context, null, activeBindings, target);
var thePlan = new plan_1.Plan(context, childRequest);
context.addPlan(thePlan);
}
else {
activeBindings = _getActiveBindings(metadataReader, avoidConstraints, context, parentRequest, target);
childRequest = parentRequest.addChildRequest(target.serviceIdentifier, activeBindings, target);
}
activeBindings.forEach(function (binding) {
var subChildRequest = null;
if (target.isArray()) {
subChildRequest = childRequest.addChildRequest(binding.serviceIdentifier, binding, target);
}
else {
if (binding.cache) {
return;
}
subChildRequest = childRequest;
}
if (binding.type === literal_types_1.BindingTypeEnum.Instance && binding.implementationType !== null) {
var dependencies = reflection_utils_1.getDependencies(metadataReader, binding.implementationType);
if (!context.container.options.skipBaseClassChecks) {
var baseClassDependencyCount = reflection_utils_1.getBaseClassDependencyCount(metadataReader, binding.implementationType);
if (dependencies.length < baseClassDependencyCount) {
var error = ERROR_MSGS.ARGUMENTS_LENGTH_MISMATCH(reflection_utils_1.getFunctionName(binding.implementationType));
throw new Error(error);
}
}
dependencies.forEach(function (dependency) {
_createSubRequests(metadataReader, false, dependency.serviceIdentifier, context, subChildRequest, dependency);
});
}
});
}
function getBindings(container, serviceIdentifier) {
var bindings = [];
var bindingDictionary = getBindingDictionary(container);
if (bindingDictionary.hasKey(serviceIdentifier)) {
bindings = bindingDictionary.get(serviceIdentifier);
}
else if (container.parent !== null) {
bindings = getBindings(container.parent, serviceIdentifier);
}
return bindings;
}
function plan(metadataReader, container, isMultiInject, targetType, serviceIdentifier, key, value, avoidConstraints) {
if (avoidConstraints === void 0) { avoidConstraints = false; }
var context = new context_1.Context(container);
var target = _createTarget(isMultiInject, targetType, serviceIdentifier, "", key, value);
try {
_createSubRequests(metadataReader, avoidConstraints, serviceIdentifier, context, null, target);
return context;
}
catch (error) {
if (exceptions_1.isStackOverflowExeption(error)) {
if (context.plan) {
serialization_1.circularDependencyToException(context.plan.rootRequest);
}
}
throw error;
}
}
exports.plan = plan;
function createMockRequest(container, serviceIdentifier, key, value) {
var target = new target_1.Target(literal_types_1.TargetTypeEnum.Variable, "", serviceIdentifier, new metadata_1.Metadata(key, value));
var context = new context_1.Context(container);
var request = new request_1.Request(serviceIdentifier, context, null, [], target);
return request;
}
exports.createMockRequest = createMockRequest;
|
