rest-client-sdk 7.2.3 → 7.4.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +6 -1
- package/dist/index.cjs +583 -1218
- package/dist/index.cjs.map +1 -1
- package/dist/index.mjs +581 -1214
- package/dist/index.mjs.map +1 -1
- package/dist/types/Mapping/ClassMetadata.d.ts +2 -2
- package/dist/types/RestClientSdk.d.ts +3 -3
- package/dist/types/RestClientSdkInterface.d.ts +1 -1
- package/dist/types/TokenGenerator/AuthorizationCodeFlowTokenGenerator.d.ts +3 -3
- package/dist/types/TokenGenerator/ClientCredentialsGenerator.d.ts +3 -3
- package/dist/types/TokenGenerator/PasswordGenerator.d.ts +3 -3
- package/dist/types/TokenGenerator/ProvidedTokenGenerator.d.ts +1 -1
- package/dist/types/TokenGenerator/TokenGeneratorInterface.d.ts +1 -1
- package/dist/types/TokenGenerator/types.d.ts +3 -3
- package/dist/types/UnitOfWork.d.ts +2 -2
- package/dist/types/client/AbstractClient.d.ts +9 -0
- package/dist/types/serializer/SerializerInterface.d.ts +4 -4
- package/dist/types/utils/logging.d.ts +5 -5
- package/package.json +28 -43
package/dist/index.cjs
CHANGED
|
@@ -1,853 +1,603 @@
|
|
|
1
1
|
(function (global, factory) {
|
|
2
2
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('urijs'), require('deep-diff')) :
|
|
3
3
|
typeof define === 'function' && define.amd ? define(['exports', 'urijs', 'deep-diff'], factory) :
|
|
4
|
-
(global = global || self, factory(global[
|
|
5
|
-
}(this, (function (exports, URI, diff) { 'use strict';
|
|
4
|
+
(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["rest-client-sdk"] = {}, global.URI, global.diff));
|
|
5
|
+
})(this, (function (exports, URI, diff) { 'use strict';
|
|
6
6
|
|
|
7
|
-
|
|
8
|
-
|
|
9
|
-
|
|
10
|
-
|
|
11
|
-
"@babel/helpers - typeof";
|
|
12
|
-
|
|
13
|
-
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
|
|
14
|
-
_typeof = function (obj) {
|
|
15
|
-
return typeof obj;
|
|
16
|
-
};
|
|
17
|
-
} else {
|
|
18
|
-
_typeof = function (obj) {
|
|
19
|
-
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
|
|
20
|
-
};
|
|
21
|
-
}
|
|
22
|
-
|
|
23
|
-
return _typeof(obj);
|
|
24
|
-
}
|
|
25
|
-
|
|
26
|
-
function _classCallCheck(instance, Constructor) {
|
|
27
|
-
if (!(instance instanceof Constructor)) {
|
|
28
|
-
throw new TypeError("Cannot call a class as a function");
|
|
29
|
-
}
|
|
30
|
-
}
|
|
31
|
-
|
|
32
|
-
function _defineProperties(target, props) {
|
|
33
|
-
for (var i = 0; i < props.length; i++) {
|
|
34
|
-
var descriptor = props[i];
|
|
35
|
-
descriptor.enumerable = descriptor.enumerable || false;
|
|
36
|
-
descriptor.configurable = true;
|
|
37
|
-
if ("value" in descriptor) descriptor.writable = true;
|
|
38
|
-
Object.defineProperty(target, descriptor.key, descriptor);
|
|
39
|
-
}
|
|
40
|
-
}
|
|
41
|
-
|
|
42
|
-
function _createClass(Constructor, protoProps, staticProps) {
|
|
43
|
-
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
|
|
44
|
-
if (staticProps) _defineProperties(Constructor, staticProps);
|
|
45
|
-
return Constructor;
|
|
46
|
-
}
|
|
47
|
-
|
|
48
|
-
function _defineProperty(obj, key, value) {
|
|
49
|
-
if (key in obj) {
|
|
50
|
-
Object.defineProperty(obj, key, {
|
|
51
|
-
value: value,
|
|
52
|
-
enumerable: true,
|
|
53
|
-
configurable: true,
|
|
54
|
-
writable: true
|
|
55
|
-
});
|
|
56
|
-
} else {
|
|
57
|
-
obj[key] = value;
|
|
58
|
-
}
|
|
59
|
-
|
|
60
|
-
return obj;
|
|
61
|
-
}
|
|
62
|
-
|
|
63
|
-
function ownKeys(object, enumerableOnly) {
|
|
64
|
-
var keys = Object.keys(object);
|
|
65
|
-
|
|
66
|
-
if (Object.getOwnPropertySymbols) {
|
|
67
|
-
var symbols = Object.getOwnPropertySymbols(object);
|
|
68
|
-
if (enumerableOnly) symbols = symbols.filter(function (sym) {
|
|
69
|
-
return Object.getOwnPropertyDescriptor(object, sym).enumerable;
|
|
70
|
-
});
|
|
71
|
-
keys.push.apply(keys, symbols);
|
|
72
|
-
}
|
|
73
|
-
|
|
74
|
-
return keys;
|
|
75
|
-
}
|
|
76
|
-
|
|
77
|
-
function _objectSpread2(target) {
|
|
78
|
-
for (var i = 1; i < arguments.length; i++) {
|
|
79
|
-
var source = arguments[i] != null ? arguments[i] : {};
|
|
80
|
-
|
|
81
|
-
if (i % 2) {
|
|
82
|
-
ownKeys(Object(source), true).forEach(function (key) {
|
|
83
|
-
_defineProperty(target, key, source[key]);
|
|
84
|
-
});
|
|
85
|
-
} else if (Object.getOwnPropertyDescriptors) {
|
|
86
|
-
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
|
|
87
|
-
} else {
|
|
88
|
-
ownKeys(Object(source)).forEach(function (key) {
|
|
89
|
-
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
|
|
90
|
-
});
|
|
91
|
-
}
|
|
92
|
-
}
|
|
93
|
-
|
|
94
|
-
return target;
|
|
95
|
-
}
|
|
96
|
-
|
|
97
|
-
function _inherits(subClass, superClass) {
|
|
98
|
-
if (typeof superClass !== "function" && superClass !== null) {
|
|
99
|
-
throw new TypeError("Super expression must either be null or a function");
|
|
100
|
-
}
|
|
101
|
-
|
|
102
|
-
subClass.prototype = Object.create(superClass && superClass.prototype, {
|
|
103
|
-
constructor: {
|
|
104
|
-
value: subClass,
|
|
105
|
-
writable: true,
|
|
106
|
-
configurable: true
|
|
107
|
-
}
|
|
108
|
-
});
|
|
109
|
-
if (superClass) _setPrototypeOf(subClass, superClass);
|
|
7
|
+
function _arrayLikeToArray(r, a) {
|
|
8
|
+
(null == a || a > r.length) && (a = r.length);
|
|
9
|
+
for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
|
|
10
|
+
return n;
|
|
110
11
|
}
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
return o.__proto__ || Object.getPrototypeOf(o);
|
|
115
|
-
};
|
|
116
|
-
return _getPrototypeOf(o);
|
|
12
|
+
function _assertClassBrand(e, t, n) {
|
|
13
|
+
if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
|
|
14
|
+
throw new TypeError("Private element is not present on this object");
|
|
117
15
|
}
|
|
118
|
-
|
|
119
|
-
|
|
120
|
-
|
|
121
|
-
o.__proto__ = p;
|
|
122
|
-
return o;
|
|
123
|
-
};
|
|
124
|
-
|
|
125
|
-
return _setPrototypeOf(o, p);
|
|
16
|
+
function _assertThisInitialized(e) {
|
|
17
|
+
if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
|
|
18
|
+
return e;
|
|
126
19
|
}
|
|
127
|
-
|
|
128
|
-
|
|
129
|
-
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
|
|
130
|
-
if (Reflect.construct.sham) return false;
|
|
131
|
-
if (typeof Proxy === "function") return true;
|
|
132
|
-
|
|
133
|
-
try {
|
|
134
|
-
Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
|
|
135
|
-
return true;
|
|
136
|
-
} catch (e) {
|
|
137
|
-
return false;
|
|
138
|
-
}
|
|
20
|
+
function _callSuper(t, o, e) {
|
|
21
|
+
return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
|
|
139
22
|
}
|
|
140
|
-
|
|
141
|
-
|
|
142
|
-
if (_isNativeReflectConstruct()) {
|
|
143
|
-
_construct = Reflect.construct;
|
|
144
|
-
} else {
|
|
145
|
-
_construct = function _construct(Parent, args, Class) {
|
|
146
|
-
var a = [null];
|
|
147
|
-
a.push.apply(a, args);
|
|
148
|
-
var Constructor = Function.bind.apply(Parent, a);
|
|
149
|
-
var instance = new Constructor();
|
|
150
|
-
if (Class) _setPrototypeOf(instance, Class.prototype);
|
|
151
|
-
return instance;
|
|
152
|
-
};
|
|
153
|
-
}
|
|
154
|
-
|
|
155
|
-
return _construct.apply(null, arguments);
|
|
23
|
+
function _checkPrivateRedeclaration(e, t) {
|
|
24
|
+
if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
|
|
156
25
|
}
|
|
157
|
-
|
|
158
|
-
|
|
159
|
-
return Function.toString.call(fn).indexOf("[native code]") !== -1;
|
|
26
|
+
function _classCallCheck(a, n) {
|
|
27
|
+
if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
|
|
160
28
|
}
|
|
161
|
-
|
|
162
|
-
|
|
163
|
-
var _cache = typeof Map === "function" ? new Map() : undefined;
|
|
164
|
-
|
|
165
|
-
_wrapNativeSuper = function _wrapNativeSuper(Class) {
|
|
166
|
-
if (Class === null || !_isNativeFunction(Class)) return Class;
|
|
167
|
-
|
|
168
|
-
if (typeof Class !== "function") {
|
|
169
|
-
throw new TypeError("Super expression must either be null or a function");
|
|
170
|
-
}
|
|
171
|
-
|
|
172
|
-
if (typeof _cache !== "undefined") {
|
|
173
|
-
if (_cache.has(Class)) return _cache.get(Class);
|
|
174
|
-
|
|
175
|
-
_cache.set(Class, Wrapper);
|
|
176
|
-
}
|
|
177
|
-
|
|
178
|
-
function Wrapper() {
|
|
179
|
-
return _construct(Class, arguments, _getPrototypeOf(this).constructor);
|
|
180
|
-
}
|
|
181
|
-
|
|
182
|
-
Wrapper.prototype = Object.create(Class.prototype, {
|
|
183
|
-
constructor: {
|
|
184
|
-
value: Wrapper,
|
|
185
|
-
enumerable: false,
|
|
186
|
-
writable: true,
|
|
187
|
-
configurable: true
|
|
188
|
-
}
|
|
189
|
-
});
|
|
190
|
-
return _setPrototypeOf(Wrapper, Class);
|
|
191
|
-
};
|
|
192
|
-
|
|
193
|
-
return _wrapNativeSuper(Class);
|
|
29
|
+
function _classPrivateFieldGet2(s, a) {
|
|
30
|
+
return s.get(_assertClassBrand(s, a));
|
|
194
31
|
}
|
|
195
|
-
|
|
196
|
-
|
|
197
|
-
if (source == null) return {};
|
|
198
|
-
var target = {};
|
|
199
|
-
var sourceKeys = Object.keys(source);
|
|
200
|
-
var key, i;
|
|
201
|
-
|
|
202
|
-
for (i = 0; i < sourceKeys.length; i++) {
|
|
203
|
-
key = sourceKeys[i];
|
|
204
|
-
if (excluded.indexOf(key) >= 0) continue;
|
|
205
|
-
target[key] = source[key];
|
|
206
|
-
}
|
|
207
|
-
|
|
208
|
-
return target;
|
|
32
|
+
function _classPrivateFieldInitSpec(e, t, a) {
|
|
33
|
+
_checkPrivateRedeclaration(e, t), t.set(e, a);
|
|
209
34
|
}
|
|
210
|
-
|
|
211
|
-
|
|
212
|
-
if (source == null) return {};
|
|
213
|
-
|
|
214
|
-
var target = _objectWithoutPropertiesLoose(source, excluded);
|
|
215
|
-
|
|
216
|
-
var key, i;
|
|
217
|
-
|
|
218
|
-
if (Object.getOwnPropertySymbols) {
|
|
219
|
-
var sourceSymbolKeys = Object.getOwnPropertySymbols(source);
|
|
220
|
-
|
|
221
|
-
for (i = 0; i < sourceSymbolKeys.length; i++) {
|
|
222
|
-
key = sourceSymbolKeys[i];
|
|
223
|
-
if (excluded.indexOf(key) >= 0) continue;
|
|
224
|
-
if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;
|
|
225
|
-
target[key] = source[key];
|
|
226
|
-
}
|
|
227
|
-
}
|
|
228
|
-
|
|
229
|
-
return target;
|
|
35
|
+
function _classPrivateFieldSet2(s, a, r) {
|
|
36
|
+
return s.set(_assertClassBrand(s, a), r), r;
|
|
230
37
|
}
|
|
231
|
-
|
|
232
|
-
|
|
233
|
-
|
|
234
|
-
|
|
235
|
-
|
|
236
|
-
|
|
237
|
-
return self;
|
|
38
|
+
function _construct(t, e, r) {
|
|
39
|
+
if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments);
|
|
40
|
+
var o = [null];
|
|
41
|
+
o.push.apply(o, e);
|
|
42
|
+
var p = new (t.bind.apply(t, o))();
|
|
43
|
+
return r && _setPrototypeOf(p, r.prototype), p;
|
|
238
44
|
}
|
|
239
|
-
|
|
240
|
-
|
|
241
|
-
|
|
242
|
-
|
|
45
|
+
function _defineProperties(e, r) {
|
|
46
|
+
for (var t = 0; t < r.length; t++) {
|
|
47
|
+
var o = r[t];
|
|
48
|
+
o.enumerable = o.enumerable || false, o.configurable = true, "value" in o && (o.writable = true), Object.defineProperty(e, _toPropertyKey(o.key), o);
|
|
243
49
|
}
|
|
244
|
-
|
|
245
|
-
return _assertThisInitialized(self);
|
|
246
|
-
}
|
|
247
|
-
|
|
248
|
-
function _createSuper(Derived) {
|
|
249
|
-
var hasNativeReflectConstruct = _isNativeReflectConstruct();
|
|
250
|
-
|
|
251
|
-
return function _createSuperInternal() {
|
|
252
|
-
var Super = _getPrototypeOf(Derived),
|
|
253
|
-
result;
|
|
254
|
-
|
|
255
|
-
if (hasNativeReflectConstruct) {
|
|
256
|
-
var NewTarget = _getPrototypeOf(this).constructor;
|
|
257
|
-
|
|
258
|
-
result = Reflect.construct(Super, arguments, NewTarget);
|
|
259
|
-
} else {
|
|
260
|
-
result = Super.apply(this, arguments);
|
|
261
|
-
}
|
|
262
|
-
|
|
263
|
-
return _possibleConstructorReturn(this, result);
|
|
264
|
-
};
|
|
265
50
|
}
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
var n = Object.prototype.toString.call(o).slice(8, -1);
|
|
271
|
-
if (n === "Object" && o.constructor) n = o.constructor.name;
|
|
272
|
-
if (n === "Map" || n === "Set") return Array.from(o);
|
|
273
|
-
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
|
|
274
|
-
}
|
|
275
|
-
|
|
276
|
-
function _arrayLikeToArray(arr, len) {
|
|
277
|
-
if (len == null || len > arr.length) len = arr.length;
|
|
278
|
-
|
|
279
|
-
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
|
|
280
|
-
|
|
281
|
-
return arr2;
|
|
51
|
+
function _createClass(e, r, t) {
|
|
52
|
+
return r && _defineProperties(e.prototype, r), Object.defineProperty(e, "prototype", {
|
|
53
|
+
writable: false
|
|
54
|
+
}), e;
|
|
282
55
|
}
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
var i = 0;
|
|
291
|
-
|
|
292
|
-
var F = function () {};
|
|
293
|
-
|
|
56
|
+
function _createForOfIteratorHelper(r, e) {
|
|
57
|
+
var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
|
|
58
|
+
if (!t) {
|
|
59
|
+
if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
|
|
60
|
+
t && (r = t);
|
|
61
|
+
var n = 0,
|
|
62
|
+
F = function () {};
|
|
294
63
|
return {
|
|
295
64
|
s: F,
|
|
296
65
|
n: function () {
|
|
297
|
-
|
|
66
|
+
return n >= r.length ? {
|
|
298
67
|
done: true
|
|
299
|
-
}
|
|
300
|
-
return {
|
|
68
|
+
} : {
|
|
301
69
|
done: false,
|
|
302
|
-
value:
|
|
70
|
+
value: r[n++]
|
|
303
71
|
};
|
|
304
72
|
},
|
|
305
|
-
e: function (
|
|
306
|
-
throw
|
|
73
|
+
e: function (r) {
|
|
74
|
+
throw r;
|
|
307
75
|
},
|
|
308
76
|
f: F
|
|
309
77
|
};
|
|
310
78
|
}
|
|
311
|
-
|
|
312
79
|
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
|
|
313
80
|
}
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
err;
|
|
81
|
+
var o,
|
|
82
|
+
a = true,
|
|
83
|
+
u = false;
|
|
318
84
|
return {
|
|
319
85
|
s: function () {
|
|
320
|
-
|
|
86
|
+
t = t.call(r);
|
|
321
87
|
},
|
|
322
88
|
n: function () {
|
|
323
|
-
var
|
|
324
|
-
|
|
325
|
-
return step;
|
|
89
|
+
var r = t.next();
|
|
90
|
+
return a = r.done, r;
|
|
326
91
|
},
|
|
327
|
-
e: function (
|
|
328
|
-
|
|
329
|
-
err = e;
|
|
92
|
+
e: function (r) {
|
|
93
|
+
u = true, o = r;
|
|
330
94
|
},
|
|
331
95
|
f: function () {
|
|
332
96
|
try {
|
|
333
|
-
|
|
97
|
+
a || null == t.return || t.return();
|
|
334
98
|
} finally {
|
|
335
|
-
if (
|
|
99
|
+
if (u) throw o;
|
|
336
100
|
}
|
|
337
101
|
}
|
|
338
102
|
};
|
|
339
103
|
}
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
|
|
344
|
-
|
|
345
|
-
|
|
104
|
+
function _defineProperty(e, r, t) {
|
|
105
|
+
return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
|
|
106
|
+
value: t,
|
|
107
|
+
enumerable: true,
|
|
108
|
+
configurable: true,
|
|
109
|
+
writable: true
|
|
110
|
+
}) : e[r] = t, e;
|
|
111
|
+
}
|
|
112
|
+
function _getPrototypeOf(t) {
|
|
113
|
+
return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) {
|
|
114
|
+
return t.__proto__ || Object.getPrototypeOf(t);
|
|
115
|
+
}, _getPrototypeOf(t);
|
|
116
|
+
}
|
|
117
|
+
function _inherits(t, e) {
|
|
118
|
+
if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function");
|
|
119
|
+
t.prototype = Object.create(e && e.prototype, {
|
|
120
|
+
constructor: {
|
|
121
|
+
value: t,
|
|
122
|
+
writable: true,
|
|
123
|
+
configurable: true
|
|
124
|
+
}
|
|
125
|
+
}), Object.defineProperty(t, "prototype", {
|
|
126
|
+
writable: false
|
|
127
|
+
}), e && _setPrototypeOf(t, e);
|
|
128
|
+
}
|
|
129
|
+
function _isNativeFunction(t) {
|
|
130
|
+
try {
|
|
131
|
+
return -1 !== Function.toString.call(t).indexOf("[native code]");
|
|
132
|
+
} catch (n) {
|
|
133
|
+
return "function" == typeof t;
|
|
346
134
|
}
|
|
347
|
-
|
|
348
|
-
|
|
349
|
-
|
|
135
|
+
}
|
|
136
|
+
function _isNativeReflectConstruct() {
|
|
137
|
+
try {
|
|
138
|
+
var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
|
|
139
|
+
} catch (t) {}
|
|
140
|
+
return (_isNativeReflectConstruct = function () {
|
|
141
|
+
return !!t;
|
|
142
|
+
})();
|
|
143
|
+
}
|
|
144
|
+
function ownKeys(e, r) {
|
|
145
|
+
var t = Object.keys(e);
|
|
146
|
+
if (Object.getOwnPropertySymbols) {
|
|
147
|
+
var o = Object.getOwnPropertySymbols(e);
|
|
148
|
+
r && (o = o.filter(function (r) {
|
|
149
|
+
return Object.getOwnPropertyDescriptor(e, r).enumerable;
|
|
150
|
+
})), t.push.apply(t, o);
|
|
350
151
|
}
|
|
351
|
-
|
|
352
|
-
return descriptor.value;
|
|
152
|
+
return t;
|
|
353
153
|
}
|
|
354
|
-
|
|
355
|
-
|
|
356
|
-
|
|
357
|
-
|
|
358
|
-
|
|
359
|
-
|
|
154
|
+
function _objectSpread2(e) {
|
|
155
|
+
for (var r = 1; r < arguments.length; r++) {
|
|
156
|
+
var t = null != arguments[r] ? arguments[r] : {};
|
|
157
|
+
r % 2 ? ownKeys(Object(t), true).forEach(function (r) {
|
|
158
|
+
_defineProperty(e, r, t[r]);
|
|
159
|
+
}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) {
|
|
160
|
+
Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
|
|
161
|
+
});
|
|
360
162
|
}
|
|
361
|
-
|
|
362
|
-
|
|
363
|
-
|
|
364
|
-
|
|
365
|
-
|
|
366
|
-
|
|
367
|
-
|
|
368
|
-
|
|
369
|
-
|
|
163
|
+
return e;
|
|
164
|
+
}
|
|
165
|
+
function _objectWithoutProperties(e, t) {
|
|
166
|
+
if (null == e) return {};
|
|
167
|
+
var o,
|
|
168
|
+
r,
|
|
169
|
+
i = _objectWithoutPropertiesLoose(e, t);
|
|
170
|
+
if (Object.getOwnPropertySymbols) {
|
|
171
|
+
var n = Object.getOwnPropertySymbols(e);
|
|
172
|
+
for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
|
|
370
173
|
}
|
|
371
|
-
|
|
372
|
-
|
|
174
|
+
return i;
|
|
175
|
+
}
|
|
176
|
+
function _objectWithoutPropertiesLoose(r, e) {
|
|
177
|
+
if (null == r) return {};
|
|
178
|
+
var t = {};
|
|
179
|
+
for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
|
|
180
|
+
if (-1 !== e.indexOf(n)) continue;
|
|
181
|
+
t[n] = r[n];
|
|
182
|
+
}
|
|
183
|
+
return t;
|
|
184
|
+
}
|
|
185
|
+
function _possibleConstructorReturn(t, e) {
|
|
186
|
+
if (e && ("object" == typeof e || "function" == typeof e)) return e;
|
|
187
|
+
if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined");
|
|
188
|
+
return _assertThisInitialized(t);
|
|
189
|
+
}
|
|
190
|
+
function _setPrototypeOf(t, e) {
|
|
191
|
+
return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
|
|
192
|
+
return t.__proto__ = e, t;
|
|
193
|
+
}, _setPrototypeOf(t, e);
|
|
373
194
|
}
|
|
195
|
+
function _toPrimitive(t, r) {
|
|
196
|
+
if ("object" != typeof t || !t) return t;
|
|
197
|
+
var e = t[Symbol.toPrimitive];
|
|
198
|
+
if (void 0 !== e) {
|
|
199
|
+
var i = e.call(t, r);
|
|
200
|
+
if ("object" != typeof i) return i;
|
|
201
|
+
throw new TypeError("@@toPrimitive must return a primitive value.");
|
|
202
|
+
}
|
|
203
|
+
return ("string" === r ? String : Number)(t);
|
|
204
|
+
}
|
|
205
|
+
function _toPropertyKey(t) {
|
|
206
|
+
var i = _toPrimitive(t, "string");
|
|
207
|
+
return "symbol" == typeof i ? i : i + "";
|
|
208
|
+
}
|
|
209
|
+
function _typeof(o) {
|
|
210
|
+
"@babel/helpers - typeof";
|
|
374
211
|
|
|
375
|
-
|
|
212
|
+
return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
|
|
213
|
+
return typeof o;
|
|
214
|
+
} : function (o) {
|
|
215
|
+
return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
|
|
216
|
+
}, _typeof(o);
|
|
217
|
+
}
|
|
218
|
+
function _unsupportedIterableToArray(r, a) {
|
|
219
|
+
if (r) {
|
|
220
|
+
if ("string" == typeof r) return _arrayLikeToArray(r, a);
|
|
221
|
+
var t = {}.toString.call(r).slice(8, -1);
|
|
222
|
+
return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
|
|
223
|
+
}
|
|
224
|
+
}
|
|
225
|
+
function _wrapNativeSuper(t) {
|
|
226
|
+
var r = "function" == typeof Map ? new Map() : void 0;
|
|
227
|
+
return _wrapNativeSuper = function (t) {
|
|
228
|
+
if (null === t || !_isNativeFunction(t)) return t;
|
|
229
|
+
if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function");
|
|
230
|
+
if (void 0 !== r) {
|
|
231
|
+
if (r.has(t)) return r.get(t);
|
|
232
|
+
r.set(t, Wrapper);
|
|
233
|
+
}
|
|
234
|
+
function Wrapper() {
|
|
235
|
+
return _construct(t, arguments, _getPrototypeOf(this).constructor);
|
|
236
|
+
}
|
|
237
|
+
return Wrapper.prototype = Object.create(t.prototype, {
|
|
238
|
+
constructor: {
|
|
239
|
+
value: Wrapper,
|
|
240
|
+
enumerable: false,
|
|
241
|
+
writable: true,
|
|
242
|
+
configurable: true
|
|
243
|
+
}
|
|
244
|
+
}), _setPrototypeOf(Wrapper, t);
|
|
245
|
+
}, _wrapNativeSuper(t);
|
|
246
|
+
}
|
|
376
247
|
|
|
377
248
|
/**
|
|
378
249
|
* It's a bit tricky to extends native errors
|
|
379
250
|
* @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
|
|
380
251
|
*/
|
|
381
252
|
var HttpError = /*#__PURE__*/function (_Error) {
|
|
382
|
-
_inherits(HttpError, _Error);
|
|
383
|
-
|
|
384
|
-
var _super = _createSuper(HttpError);
|
|
385
|
-
|
|
386
253
|
function HttpError(message, baseResponse) {
|
|
387
254
|
var _this;
|
|
388
|
-
|
|
389
255
|
_classCallCheck(this, HttpError);
|
|
256
|
+
_this = _callSuper(this, HttpError, [message || 'Http errort']);
|
|
390
257
|
|
|
391
|
-
|
|
392
|
-
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
Object.setPrototypeOf(_assertThisInitialized(_this), OauthError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
258
|
+
// Set the prototype explicitly.
|
|
259
|
+
_defineProperty(_this, "baseResponse", void 0);
|
|
260
|
+
Object.setPrototypeOf(_this, OauthError.prototype);
|
|
396
261
|
|
|
262
|
+
// Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
397
263
|
if (Error.captureStackTrace) {
|
|
398
|
-
Error.captureStackTrace(
|
|
264
|
+
Error.captureStackTrace(_this, OauthError);
|
|
399
265
|
}
|
|
400
|
-
|
|
401
266
|
_this.name = 'HttpError';
|
|
402
267
|
_this.baseResponse = baseResponse;
|
|
403
268
|
return _this;
|
|
404
269
|
}
|
|
270
|
+
|
|
405
271
|
/**
|
|
406
272
|
* Get the JSON of the baseResponse directly, if possible
|
|
407
273
|
*/
|
|
408
|
-
|
|
409
|
-
|
|
410
|
-
_createClass(HttpError, [{
|
|
274
|
+
_inherits(HttpError, _Error);
|
|
275
|
+
return _createClass(HttpError, [{
|
|
411
276
|
key: "responseJson",
|
|
412
277
|
value: function responseJson() {
|
|
413
278
|
return this.baseResponse.json();
|
|
414
279
|
}
|
|
415
280
|
}]);
|
|
416
|
-
|
|
417
|
-
return HttpError;
|
|
418
|
-
}( /*#__PURE__*/_wrapNativeSuper(Error));
|
|
419
|
-
|
|
281
|
+
}(/*#__PURE__*/_wrapNativeSuper(Error));
|
|
420
282
|
var OauthError = /*#__PURE__*/function (_Error2) {
|
|
421
|
-
_inherits(OauthError, _Error2);
|
|
422
|
-
|
|
423
|
-
var _super2 = _createSuper(OauthError);
|
|
424
|
-
|
|
425
283
|
function OauthError(message, previousError) {
|
|
426
284
|
var _this2;
|
|
427
|
-
|
|
428
285
|
_classCallCheck(this, OauthError);
|
|
286
|
+
_this2 = _callSuper(this, OauthError, [message || 'Oauth error']);
|
|
429
287
|
|
|
430
|
-
|
|
431
|
-
|
|
432
|
-
|
|
433
|
-
|
|
434
|
-
Object.setPrototypeOf(_assertThisInitialized(_this2), OauthError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
288
|
+
// Set the prototype explicitly.
|
|
289
|
+
_defineProperty(_this2, "previousError", void 0);
|
|
290
|
+
Object.setPrototypeOf(_this2, OauthError.prototype);
|
|
435
291
|
|
|
292
|
+
// Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
436
293
|
if (Error.captureStackTrace) {
|
|
437
|
-
Error.captureStackTrace(
|
|
294
|
+
Error.captureStackTrace(_this2, OauthError);
|
|
438
295
|
}
|
|
439
|
-
|
|
440
296
|
_this2.name = 'OauthError';
|
|
441
297
|
_this2.previousError = previousError;
|
|
442
298
|
return _this2;
|
|
443
299
|
}
|
|
444
|
-
|
|
445
|
-
return OauthError;
|
|
446
|
-
}(
|
|
447
|
-
|
|
448
|
-
var InvalidGrantError = /*#__PURE__*/function (_OauthError) {
|
|
449
|
-
_inherits(InvalidGrantError, _OauthError);
|
|
450
|
-
|
|
451
|
-
var _super3 = _createSuper(InvalidGrantError);
|
|
452
|
-
|
|
300
|
+
_inherits(OauthError, _Error2);
|
|
301
|
+
return _createClass(OauthError);
|
|
302
|
+
}(/*#__PURE__*/_wrapNativeSuper(Error));
|
|
303
|
+
var InvalidGrantError = /*#__PURE__*/function (_OauthError2) {
|
|
453
304
|
function InvalidGrantError(message, previousError) {
|
|
454
305
|
var _this3;
|
|
455
|
-
|
|
456
306
|
_classCallCheck(this, InvalidGrantError);
|
|
307
|
+
_this3 = _callSuper(this, InvalidGrantError, [message || 'Invalid grant error', previousError]);
|
|
457
308
|
|
|
458
|
-
|
|
459
|
-
|
|
460
|
-
|
|
461
|
-
|
|
462
|
-
Object.setPrototypeOf(_assertThisInitialized(_this3), InvalidGrantError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
309
|
+
// Set the prototype explicitly.
|
|
310
|
+
_defineProperty(_this3, "previousError", void 0);
|
|
311
|
+
Object.setPrototypeOf(_this3, InvalidGrantError.prototype);
|
|
463
312
|
|
|
313
|
+
// Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
464
314
|
if (Error.captureStackTrace) {
|
|
465
|
-
Error.captureStackTrace(
|
|
315
|
+
Error.captureStackTrace(_this3, InvalidGrantError);
|
|
466
316
|
}
|
|
467
|
-
|
|
468
317
|
_this3.name = 'InvalidGrantError';
|
|
469
318
|
_this3.previousError = previousError;
|
|
470
319
|
return _this3;
|
|
471
320
|
}
|
|
472
|
-
|
|
473
|
-
return InvalidGrantError;
|
|
321
|
+
_inherits(InvalidGrantError, _OauthError2);
|
|
322
|
+
return _createClass(InvalidGrantError);
|
|
474
323
|
}(OauthError);
|
|
475
|
-
|
|
476
|
-
var InvalidScopeError = /*#__PURE__*/function (_OauthError2) {
|
|
477
|
-
_inherits(InvalidScopeError, _OauthError2);
|
|
478
|
-
|
|
479
|
-
var _super4 = _createSuper(InvalidScopeError);
|
|
480
|
-
|
|
324
|
+
var InvalidScopeError = /*#__PURE__*/function (_OauthError3) {
|
|
481
325
|
function InvalidScopeError(message, previousError) {
|
|
482
326
|
var _this4;
|
|
483
|
-
|
|
484
327
|
_classCallCheck(this, InvalidScopeError);
|
|
328
|
+
_this4 = _callSuper(this, InvalidScopeError, [message || 'Invalid scope error', previousError]);
|
|
485
329
|
|
|
486
|
-
|
|
487
|
-
|
|
488
|
-
|
|
489
|
-
|
|
490
|
-
Object.setPrototypeOf(_assertThisInitialized(_this4), InvalidScopeError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
330
|
+
// Set the prototype explicitly.
|
|
331
|
+
_defineProperty(_this4, "previousError", void 0);
|
|
332
|
+
Object.setPrototypeOf(_this4, InvalidScopeError.prototype);
|
|
491
333
|
|
|
334
|
+
// Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
492
335
|
if (Error.captureStackTrace) {
|
|
493
|
-
Error.captureStackTrace(
|
|
336
|
+
Error.captureStackTrace(_this4, InvalidScopeError);
|
|
494
337
|
}
|
|
495
|
-
|
|
496
338
|
_this4.name = 'InvalidScopeError';
|
|
497
339
|
_this4.previousError = previousError;
|
|
498
340
|
return _this4;
|
|
499
341
|
}
|
|
500
|
-
|
|
501
|
-
return InvalidScopeError;
|
|
342
|
+
_inherits(InvalidScopeError, _OauthError3);
|
|
343
|
+
return _createClass(InvalidScopeError);
|
|
502
344
|
}(OauthError); // 400
|
|
503
|
-
|
|
504
|
-
|
|
505
|
-
var BadRequestError = /*#__PURE__*/function (_HttpError) {
|
|
506
|
-
_inherits(BadRequestError, _HttpError);
|
|
507
|
-
|
|
508
|
-
var _super5 = _createSuper(BadRequestError);
|
|
509
|
-
|
|
345
|
+
var BadRequestError = /*#__PURE__*/function (_HttpError2) {
|
|
510
346
|
function BadRequestError(message, baseResponse) {
|
|
511
347
|
var _this5;
|
|
512
|
-
|
|
513
348
|
_classCallCheck(this, BadRequestError);
|
|
349
|
+
_this5 = _callSuper(this, BadRequestError, [message || 'Bad request', baseResponse]);
|
|
514
350
|
|
|
515
|
-
|
|
516
|
-
|
|
517
|
-
|
|
518
|
-
|
|
519
|
-
Object.setPrototypeOf(_assertThisInitialized(_this5), BadRequestError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
351
|
+
// Set the prototype explicitly.
|
|
352
|
+
_defineProperty(_this5, "baseResponse", void 0);
|
|
353
|
+
Object.setPrototypeOf(_this5, BadRequestError.prototype);
|
|
520
354
|
|
|
355
|
+
// Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
521
356
|
if (Error.captureStackTrace) {
|
|
522
|
-
Error.captureStackTrace(
|
|
357
|
+
Error.captureStackTrace(_this5, BadRequestError);
|
|
523
358
|
}
|
|
524
|
-
|
|
525
359
|
_this5.name = 'BadRequestError';
|
|
526
360
|
_this5.baseResponse = baseResponse;
|
|
527
361
|
return _this5;
|
|
528
362
|
}
|
|
529
|
-
|
|
530
|
-
return BadRequestError;
|
|
363
|
+
_inherits(BadRequestError, _HttpError2);
|
|
364
|
+
return _createClass(BadRequestError);
|
|
531
365
|
}(HttpError); // 401
|
|
532
|
-
|
|
533
|
-
|
|
534
|
-
var UnauthorizedError = /*#__PURE__*/function (_BadRequestError) {
|
|
535
|
-
_inherits(UnauthorizedError, _BadRequestError);
|
|
536
|
-
|
|
537
|
-
var _super6 = _createSuper(UnauthorizedError);
|
|
538
|
-
|
|
366
|
+
var UnauthorizedError = /*#__PURE__*/function (_BadRequestError2) {
|
|
539
367
|
function UnauthorizedError(message, baseResponse) {
|
|
540
368
|
var _this6;
|
|
541
|
-
|
|
542
369
|
_classCallCheck(this, UnauthorizedError);
|
|
370
|
+
_this6 = _callSuper(this, UnauthorizedError, [message || 'Unauthorized', baseResponse]);
|
|
543
371
|
|
|
544
|
-
|
|
545
|
-
|
|
546
|
-
|
|
547
|
-
|
|
548
|
-
Object.setPrototypeOf(_assertThisInitialized(_this6), UnauthorizedError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
372
|
+
// Set the prototype explicitly.
|
|
373
|
+
_defineProperty(_this6, "baseResponse", void 0);
|
|
374
|
+
Object.setPrototypeOf(_this6, UnauthorizedError.prototype);
|
|
549
375
|
|
|
376
|
+
// Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
550
377
|
if (Error.captureStackTrace) {
|
|
551
|
-
Error.captureStackTrace(
|
|
378
|
+
Error.captureStackTrace(_this6, UnauthorizedError);
|
|
552
379
|
}
|
|
553
|
-
|
|
554
380
|
_this6.name = 'UnauthorizedError';
|
|
555
381
|
_this6.baseResponse = baseResponse;
|
|
556
382
|
return _this6;
|
|
557
383
|
}
|
|
558
|
-
|
|
559
|
-
return UnauthorizedError;
|
|
384
|
+
_inherits(UnauthorizedError, _BadRequestError2);
|
|
385
|
+
return _createClass(UnauthorizedError);
|
|
560
386
|
}(BadRequestError); // 403
|
|
561
|
-
|
|
562
|
-
|
|
563
|
-
var ForbiddenError = /*#__PURE__*/function (_BadRequestError2) {
|
|
564
|
-
_inherits(ForbiddenError, _BadRequestError2);
|
|
565
|
-
|
|
566
|
-
var _super7 = _createSuper(ForbiddenError);
|
|
567
|
-
|
|
387
|
+
var ForbiddenError = /*#__PURE__*/function (_BadRequestError3) {
|
|
568
388
|
function ForbiddenError(message, baseResponse) {
|
|
569
389
|
var _this7;
|
|
570
|
-
|
|
571
390
|
_classCallCheck(this, ForbiddenError);
|
|
391
|
+
_this7 = _callSuper(this, ForbiddenError, [message || 'Forbidden', baseResponse]);
|
|
572
392
|
|
|
573
|
-
|
|
574
|
-
|
|
575
|
-
|
|
576
|
-
|
|
577
|
-
Object.setPrototypeOf(_assertThisInitialized(_this7), ForbiddenError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
393
|
+
// Set the prototype explicitly.
|
|
394
|
+
_defineProperty(_this7, "baseResponse", void 0);
|
|
395
|
+
Object.setPrototypeOf(_this7, ForbiddenError.prototype);
|
|
578
396
|
|
|
397
|
+
// Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
579
398
|
if (Error.captureStackTrace) {
|
|
580
|
-
Error.captureStackTrace(
|
|
399
|
+
Error.captureStackTrace(_this7, ForbiddenError);
|
|
581
400
|
}
|
|
582
|
-
|
|
583
401
|
_this7.name = 'ForbiddenError';
|
|
584
402
|
_this7.baseResponse = baseResponse;
|
|
585
403
|
return _this7;
|
|
586
404
|
}
|
|
587
|
-
|
|
588
|
-
return ForbiddenError;
|
|
405
|
+
_inherits(ForbiddenError, _BadRequestError3);
|
|
406
|
+
return _createClass(ForbiddenError);
|
|
589
407
|
}(BadRequestError); // 404
|
|
590
|
-
|
|
591
|
-
|
|
592
|
-
var ResourceNotFoundError = /*#__PURE__*/function (_BadRequestError3) {
|
|
593
|
-
_inherits(ResourceNotFoundError, _BadRequestError3);
|
|
594
|
-
|
|
595
|
-
var _super8 = _createSuper(ResourceNotFoundError);
|
|
596
|
-
|
|
408
|
+
var ResourceNotFoundError = /*#__PURE__*/function (_BadRequestError4) {
|
|
597
409
|
function ResourceNotFoundError(message, baseResponse) {
|
|
598
410
|
var _this8;
|
|
599
|
-
|
|
600
411
|
_classCallCheck(this, ResourceNotFoundError);
|
|
412
|
+
_this8 = _callSuper(this, ResourceNotFoundError, [message || 'Resource is not found', baseResponse]);
|
|
601
413
|
|
|
602
|
-
|
|
603
|
-
|
|
604
|
-
|
|
605
|
-
|
|
606
|
-
Object.setPrototypeOf(_assertThisInitialized(_this8), ResourceNotFoundError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
414
|
+
// Set the prototype explicitly.
|
|
415
|
+
_defineProperty(_this8, "baseResponse", void 0);
|
|
416
|
+
Object.setPrototypeOf(_this8, ResourceNotFoundError.prototype);
|
|
607
417
|
|
|
418
|
+
// Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
608
419
|
if (Error.captureStackTrace) {
|
|
609
|
-
Error.captureStackTrace(
|
|
420
|
+
Error.captureStackTrace(_this8, ResourceNotFoundError);
|
|
610
421
|
}
|
|
611
|
-
|
|
612
422
|
_this8.name = 'ResourceNotFoundError';
|
|
613
423
|
_this8.baseResponse = baseResponse;
|
|
614
424
|
return _this8;
|
|
615
425
|
}
|
|
616
|
-
|
|
617
|
-
return ResourceNotFoundError;
|
|
426
|
+
_inherits(ResourceNotFoundError, _BadRequestError4);
|
|
427
|
+
return _createClass(ResourceNotFoundError);
|
|
618
428
|
}(BadRequestError); // 409
|
|
619
|
-
|
|
620
|
-
|
|
621
|
-
var ConflictError = /*#__PURE__*/function (_BadRequestError4) {
|
|
622
|
-
_inherits(ConflictError, _BadRequestError4);
|
|
623
|
-
|
|
624
|
-
var _super9 = _createSuper(ConflictError);
|
|
625
|
-
|
|
429
|
+
var ConflictError = /*#__PURE__*/function (_BadRequestError5) {
|
|
626
430
|
function ConflictError(message, baseResponse) {
|
|
627
431
|
var _this9;
|
|
628
|
-
|
|
629
432
|
_classCallCheck(this, ConflictError);
|
|
433
|
+
_this9 = _callSuper(this, ConflictError, [message || 'Conflict detected', baseResponse]);
|
|
630
434
|
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
|
|
634
|
-
|
|
635
|
-
Object.setPrototypeOf(_assertThisInitialized(_this9), ConflictError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
435
|
+
// Set the prototype explicitly.
|
|
436
|
+
_defineProperty(_this9, "baseResponse", void 0);
|
|
437
|
+
Object.setPrototypeOf(_this9, ConflictError.prototype);
|
|
636
438
|
|
|
439
|
+
// Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
637
440
|
if (Error.captureStackTrace) {
|
|
638
|
-
Error.captureStackTrace(
|
|
441
|
+
Error.captureStackTrace(_this9, ConflictError);
|
|
639
442
|
}
|
|
640
|
-
|
|
641
443
|
_this9.name = 'ConflictError';
|
|
642
444
|
_this9.baseResponse = baseResponse;
|
|
643
445
|
return _this9;
|
|
644
446
|
}
|
|
645
|
-
|
|
646
|
-
return ConflictError;
|
|
447
|
+
_inherits(ConflictError, _BadRequestError5);
|
|
448
|
+
return _createClass(ConflictError);
|
|
647
449
|
}(BadRequestError); // 500
|
|
648
|
-
|
|
649
|
-
|
|
650
|
-
var InternalServerError = /*#__PURE__*/function (_HttpError2) {
|
|
651
|
-
_inherits(InternalServerError, _HttpError2);
|
|
652
|
-
|
|
653
|
-
var _super10 = _createSuper(InternalServerError);
|
|
654
|
-
|
|
450
|
+
var InternalServerError = /*#__PURE__*/function (_HttpError3) {
|
|
655
451
|
function InternalServerError(message, baseResponse) {
|
|
656
|
-
var
|
|
657
|
-
|
|
452
|
+
var _this0;
|
|
658
453
|
_classCallCheck(this, InternalServerError);
|
|
454
|
+
_this0 = _callSuper(this, InternalServerError, [message || 'Internal server error', baseResponse]);
|
|
659
455
|
|
|
660
|
-
|
|
661
|
-
|
|
662
|
-
|
|
663
|
-
|
|
664
|
-
Object.setPrototypeOf(_assertThisInitialized(_this10), InternalServerError.prototype); // Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
456
|
+
// Set the prototype explicitly.
|
|
457
|
+
_defineProperty(_this0, "baseResponse", void 0);
|
|
458
|
+
Object.setPrototypeOf(_this0, InternalServerError.prototype);
|
|
665
459
|
|
|
460
|
+
// Maintains proper stack trace for where our error was thrown (only available on V8)
|
|
666
461
|
if (Error.captureStackTrace) {
|
|
667
|
-
Error.captureStackTrace(
|
|
462
|
+
Error.captureStackTrace(_this0, InternalServerError);
|
|
668
463
|
}
|
|
669
|
-
|
|
670
|
-
|
|
671
|
-
|
|
672
|
-
return _this10;
|
|
464
|
+
_this0.name = 'InternalServerError';
|
|
465
|
+
_this0.baseResponse = baseResponse;
|
|
466
|
+
return _this0;
|
|
673
467
|
}
|
|
674
|
-
|
|
675
|
-
return InternalServerError;
|
|
468
|
+
_inherits(InternalServerError, _HttpError3);
|
|
469
|
+
return _createClass(InternalServerError);
|
|
676
470
|
}(HttpError);
|
|
677
471
|
/**
|
|
678
472
|
* @returns {HttpError}
|
|
679
473
|
*/
|
|
680
|
-
|
|
681
|
-
|
|
682
474
|
function getHttpErrorFromResponse(originalResponse) {
|
|
683
475
|
var response = originalResponse.clone();
|
|
684
|
-
|
|
685
476
|
switch (true) {
|
|
686
477
|
case response.status === 401:
|
|
687
478
|
return new UnauthorizedError(null, response);
|
|
688
|
-
|
|
689
479
|
case response.status === 403:
|
|
690
480
|
return new ForbiddenError(null, response);
|
|
691
|
-
|
|
692
481
|
case response.status === 404:
|
|
693
482
|
return new ResourceNotFoundError(null, response);
|
|
694
|
-
|
|
695
483
|
case response.status === 409:
|
|
696
484
|
return new ConflictError(null, response);
|
|
697
|
-
|
|
698
485
|
case response.status >= 400 && response.status < 500:
|
|
699
486
|
return new BadRequestError(null, response);
|
|
700
|
-
|
|
701
487
|
case response.status >= 500 && response.status < 600:
|
|
702
488
|
return new InternalServerError(null, response);
|
|
703
|
-
|
|
704
489
|
default:
|
|
705
490
|
return new HttpError(null, response);
|
|
706
491
|
}
|
|
707
492
|
}
|
|
708
|
-
|
|
709
493
|
function isOauthError(body) {
|
|
710
|
-
|
|
711
|
-
|
|
712
|
-
return typeof ((_ref = body) === null || _ref === void 0 ? void 0 : _ref.error) === 'string';
|
|
494
|
+
return typeof (body === null || body === void 0 ? void 0 : body.error) === 'string';
|
|
713
495
|
}
|
|
714
496
|
|
|
715
497
|
var DEFAULT_CONFIG = {
|
|
716
498
|
collectionKey: 'hydra:member'
|
|
717
499
|
};
|
|
718
|
-
|
|
719
|
-
var
|
|
720
|
-
|
|
721
|
-
var _classMetadataList = new WeakMap();
|
|
722
|
-
|
|
500
|
+
var _config = /*#__PURE__*/new WeakMap();
|
|
501
|
+
var _classMetadataList = /*#__PURE__*/new WeakMap();
|
|
723
502
|
var Mapping = /*#__PURE__*/function () {
|
|
724
503
|
function Mapping() {
|
|
725
504
|
var idPrefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
|
|
726
505
|
var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
727
|
-
|
|
728
506
|
_classCallCheck(this, Mapping);
|
|
729
|
-
|
|
730
507
|
_defineProperty(this, "idPrefix", void 0);
|
|
731
|
-
|
|
732
|
-
|
|
733
|
-
writable: true,
|
|
734
|
-
value: void 0
|
|
735
|
-
});
|
|
736
|
-
|
|
737
|
-
_classMetadataList.set(this, {
|
|
738
|
-
writable: true,
|
|
739
|
-
value: void 0
|
|
740
|
-
});
|
|
741
|
-
|
|
508
|
+
_classPrivateFieldInitSpec(this, _config, void 0);
|
|
509
|
+
_classPrivateFieldInitSpec(this, _classMetadataList, void 0);
|
|
742
510
|
this.idPrefix = idPrefix;
|
|
743
|
-
|
|
744
|
-
_classPrivateFieldSet(this, _classMetadataList, []);
|
|
745
|
-
|
|
511
|
+
_classPrivateFieldSet2(_classMetadataList, this, []);
|
|
746
512
|
this.setConfig(config);
|
|
747
513
|
}
|
|
748
|
-
|
|
749
|
-
_createClass(Mapping, [{
|
|
514
|
+
return _createClass(Mapping, [{
|
|
750
515
|
key: "getConfig",
|
|
751
516
|
value: function getConfig() {
|
|
752
|
-
return
|
|
517
|
+
return _classPrivateFieldGet2(_config, this);
|
|
753
518
|
}
|
|
754
519
|
}, {
|
|
755
520
|
key: "setConfig",
|
|
756
521
|
value: function setConfig(config) {
|
|
757
|
-
|
|
522
|
+
_classPrivateFieldSet2(_config, this, _objectSpread2(_objectSpread2({}, DEFAULT_CONFIG), config));
|
|
758
523
|
}
|
|
759
524
|
}, {
|
|
760
525
|
key: "setMapping",
|
|
761
526
|
value: function setMapping() {
|
|
762
527
|
var classMetadataList = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
763
|
-
|
|
764
|
-
_classPrivateFieldSet(this, _classMetadataList, classMetadataList);
|
|
528
|
+
_classPrivateFieldSet2(_classMetadataList, this, classMetadataList);
|
|
765
529
|
}
|
|
766
530
|
}, {
|
|
767
531
|
key: "getMappingKeys",
|
|
768
532
|
value: function getMappingKeys() {
|
|
769
|
-
return
|
|
533
|
+
return _classPrivateFieldGet2(_classMetadataList, this).map(function (classMetadata) {
|
|
770
534
|
return classMetadata.key;
|
|
771
535
|
});
|
|
772
536
|
}
|
|
773
537
|
}, {
|
|
774
538
|
key: "getClassMetadataByKey",
|
|
775
539
|
value: function getClassMetadataByKey(key) {
|
|
776
|
-
var filterList =
|
|
540
|
+
var filterList = _classPrivateFieldGet2(_classMetadataList, this).filter(function (classMetadata) {
|
|
777
541
|
return classMetadata.key === key;
|
|
778
542
|
});
|
|
779
|
-
|
|
780
543
|
return filterList.length > 0 ? filterList[0] : null;
|
|
781
544
|
}
|
|
782
545
|
}, {
|
|
783
546
|
key: "isMappingValid",
|
|
784
547
|
value: function isMappingValid() {
|
|
785
548
|
var _this = this;
|
|
786
|
-
|
|
787
|
-
return !_classPrivateFieldGet(this, _classMetadataList).some(function (classMetadata) {
|
|
549
|
+
return !_classPrivateFieldGet2(_classMetadataList, this).some(function (classMetadata) {
|
|
788
550
|
// check that the relations exists
|
|
789
551
|
var errorList = Object.values(classMetadata.getAttributeList()).map(function (attribute) {
|
|
790
552
|
var relation = classMetadata.getRelation(attribute.serializedKey);
|
|
791
|
-
|
|
792
553
|
if (!relation) {
|
|
793
554
|
// attribute can not be "invalid" (for now ?)
|
|
794
555
|
return false;
|
|
795
556
|
}
|
|
557
|
+
var relationMetadata = _this.getClassMetadataByKey(relation.targetMetadataKey);
|
|
796
558
|
|
|
797
|
-
|
|
798
|
-
|
|
799
|
-
|
|
559
|
+
// relation name seems weird
|
|
800
560
|
if (relation.isRelationToOne() && attribute.attributeName.endsWith('List')) {
|
|
801
561
|
return "\"".concat(classMetadata.key, ".").concat(attribute.serializedKey, " is defined as a MANY_TO_ONE relation, but the attribute name ends with \"List\".");
|
|
802
562
|
}
|
|
803
|
-
|
|
804
563
|
if (relation.isRelationToMany()) {
|
|
805
564
|
var message = "\"".concat(classMetadata.key, ".").concat(attribute.serializedKey, " is defined as a ").concat(relation.type, " relation, but the attribute name is nor plural not ends with \"List\".");
|
|
806
565
|
var endsWithList = attribute.attributeName.endsWith('List');
|
|
807
|
-
|
|
808
566
|
try {
|
|
809
|
-
// eslint-disable-next-line
|
|
567
|
+
// eslint-disable-next-line @typescript-eslint/no-require-imports
|
|
810
568
|
var pluralize = require('pluralize');
|
|
811
|
-
|
|
812
569
|
if (!endsWithList && !pluralize.isPlural(attribute.attributeName)) {
|
|
813
570
|
return message;
|
|
814
571
|
}
|
|
815
|
-
} catch (
|
|
572
|
+
} catch (_unused) {
|
|
816
573
|
if (!endsWithList) {
|
|
817
574
|
return "".concat(message, ".\nIf your keys does not ends with \"List\", then you should install the \"pluralize\" package.");
|
|
818
575
|
}
|
|
819
576
|
}
|
|
820
|
-
}
|
|
821
|
-
|
|
577
|
+
}
|
|
822
578
|
|
|
579
|
+
// no error if there is metadata linked
|
|
823
580
|
if (!relationMetadata) {
|
|
824
581
|
return "\"".concat(classMetadata.key, ".").concat(attribute.serializedKey, "\" defined a relation to the metadata named \"").concat(relation.targetMetadataKey, "\" but this metadata is not knowned by the mapping");
|
|
825
582
|
}
|
|
826
|
-
|
|
827
583
|
return false;
|
|
828
584
|
});
|
|
829
|
-
|
|
830
585
|
if (!classMetadata.hasIdentifierAttribute()) {
|
|
831
586
|
errorList.push("\"".concat(classMetadata.key, "\" has no identifier attribute set"));
|
|
832
587
|
}
|
|
833
|
-
|
|
834
588
|
var nbError = errorList.filter(function (error) {
|
|
835
589
|
if (error) {
|
|
836
|
-
// eslint-disable-next-line no-console
|
|
837
590
|
console.warn(error);
|
|
838
591
|
}
|
|
839
|
-
|
|
840
592
|
return error;
|
|
841
593
|
});
|
|
842
594
|
return nbError.length > 0;
|
|
843
595
|
});
|
|
844
596
|
}
|
|
845
597
|
}]);
|
|
846
|
-
|
|
847
|
-
return Mapping;
|
|
848
598
|
}();
|
|
849
599
|
|
|
850
|
-
var Attribute =
|
|
600
|
+
var Attribute = /*#__PURE__*/_createClass(
|
|
851
601
|
/**
|
|
852
602
|
* @param {string} serializedKey the key returned from your API
|
|
853
603
|
* @param {null|string} attributeName the name in your entity, default to the `serializedKey` attribute
|
|
@@ -858,143 +608,104 @@
|
|
|
858
608
|
var attributeName = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
859
609
|
var type = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'string';
|
|
860
610
|
var isIdentifier = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
|
|
861
|
-
|
|
862
611
|
_classCallCheck(this, Attribute);
|
|
863
|
-
|
|
864
612
|
_defineProperty(this, "serializedKey", void 0);
|
|
865
|
-
|
|
866
613
|
_defineProperty(this, "attributeName", void 0);
|
|
867
|
-
|
|
868
614
|
_defineProperty(this, "type", void 0);
|
|
869
|
-
|
|
870
615
|
_defineProperty(this, "isIdentifier", void 0);
|
|
871
|
-
|
|
872
616
|
if (!serializedKey) {
|
|
873
617
|
throw new TypeError('`serializedKey` must not be empty');
|
|
874
618
|
}
|
|
875
|
-
|
|
876
619
|
this.serializedKey = serializedKey;
|
|
877
620
|
this.attributeName = attributeName || this.serializedKey;
|
|
878
621
|
this.type = type;
|
|
879
622
|
this.isIdentifier = isIdentifier;
|
|
880
|
-
};
|
|
623
|
+
});
|
|
881
624
|
|
|
882
|
-
/* eslint-disable import/prefer-default-export */
|
|
883
|
-
// eslint-disable-next-line import/no-duplicates
|
|
884
|
-
// eslint-disable-next-line import/no-duplicates
|
|
885
625
|
function generateRepository(sdk, metadata) {
|
|
886
626
|
var isUnitOfWorkEnabled = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
|
|
887
627
|
// eslint-disable-next-line new-cap
|
|
888
628
|
return new metadata.repositoryClass(sdk, metadata, isUnitOfWorkEnabled);
|
|
889
629
|
}
|
|
890
630
|
|
|
891
|
-
/* eslint-disable consistent-return */
|
|
892
631
|
function removeAuthorization(headers) {
|
|
893
632
|
if (!headers) {
|
|
894
633
|
return;
|
|
895
634
|
}
|
|
896
|
-
|
|
897
635
|
if (headers instanceof Headers) {
|
|
898
636
|
headers["delete"]('Authorization');
|
|
899
637
|
return headers;
|
|
900
638
|
}
|
|
901
|
-
|
|
902
639
|
var filterAuthorization = function filterAuthorization(entries) {
|
|
903
640
|
return entries.filter(function (header) {
|
|
904
641
|
return header[0] !== 'Authorization';
|
|
905
642
|
});
|
|
906
643
|
};
|
|
907
|
-
|
|
908
644
|
if (Array.isArray(headers)) {
|
|
909
645
|
return filterAuthorization(headers);
|
|
910
646
|
}
|
|
911
|
-
|
|
912
647
|
return Object.fromEntries(filterAuthorization(Object.entries(headers)));
|
|
913
648
|
}
|
|
649
|
+
|
|
914
650
|
/**
|
|
915
651
|
* remove undefined key, usefull to remove Content-Type for example.
|
|
916
652
|
* Does not apply on "Headers" instance as values are string in there.
|
|
917
653
|
*/
|
|
918
|
-
|
|
919
654
|
function removeUndefinedHeaders(headers) {
|
|
920
655
|
if (headers instanceof Headers) {
|
|
921
656
|
return headers;
|
|
922
657
|
}
|
|
923
|
-
|
|
924
658
|
var filterEntries = function filterEntries(entries) {
|
|
925
659
|
return entries.filter(function (header) {
|
|
926
660
|
return header[1] !== undefined;
|
|
927
661
|
});
|
|
928
662
|
};
|
|
929
|
-
|
|
930
663
|
if (Array.isArray(headers)) {
|
|
931
664
|
return filterEntries(headers);
|
|
932
665
|
}
|
|
933
|
-
|
|
934
666
|
return Object.fromEntries(filterEntries(Object.entries(headers)));
|
|
935
667
|
}
|
|
936
668
|
function convertToRecord(headers) {
|
|
937
669
|
if (headers instanceof Headers) {
|
|
938
670
|
return Object.fromEntries(headers.entries());
|
|
939
671
|
}
|
|
940
|
-
|
|
941
672
|
if (Array.isArray(headers)) {
|
|
942
673
|
return Object.fromEntries(headers);
|
|
943
674
|
}
|
|
944
|
-
|
|
945
675
|
return headers;
|
|
946
676
|
}
|
|
947
677
|
|
|
948
|
-
var
|
|
949
|
-
|
|
950
|
-
var _tokenStorage = new WeakMap();
|
|
951
|
-
|
|
952
|
-
var _isUnitOfWorkEnabled = new WeakMap();
|
|
953
|
-
|
|
678
|
+
var _excluded = ["headers"];
|
|
679
|
+
var EXPIRE_LIMIT_SECONDS = 300; // = 5 minutes
|
|
680
|
+
var _tokenStorage = /*#__PURE__*/new WeakMap();
|
|
681
|
+
var _isUnitOfWorkEnabled = /*#__PURE__*/new WeakMap();
|
|
954
682
|
var AbstractClient = /*#__PURE__*/function () {
|
|
955
683
|
function AbstractClient(sdk, metadata) {
|
|
956
684
|
var isUnitOfWorkEnabled = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
|
|
957
|
-
|
|
958
685
|
_classCallCheck(this, AbstractClient);
|
|
959
|
-
|
|
960
686
|
_defineProperty(this, "sdk", void 0);
|
|
961
|
-
|
|
962
|
-
_tokenStorage.set(this, {
|
|
963
|
-
writable: true,
|
|
964
|
-
value: void 0
|
|
965
|
-
});
|
|
966
|
-
|
|
687
|
+
_classPrivateFieldInitSpec(this, _tokenStorage, void 0);
|
|
967
688
|
_defineProperty(this, "serializer", void 0);
|
|
968
|
-
|
|
969
689
|
_defineProperty(this, "metadata", void 0);
|
|
970
|
-
|
|
971
|
-
_isUnitOfWorkEnabled.set(this, {
|
|
972
|
-
writable: true,
|
|
973
|
-
value: void 0
|
|
974
|
-
});
|
|
975
|
-
|
|
690
|
+
_classPrivateFieldInitSpec(this, _isUnitOfWorkEnabled, void 0);
|
|
976
691
|
this.sdk = sdk;
|
|
977
|
-
|
|
978
|
-
_classPrivateFieldSet(this, _tokenStorage, sdk.tokenStorage);
|
|
979
|
-
|
|
692
|
+
_classPrivateFieldSet2(_tokenStorage, this, sdk.tokenStorage);
|
|
980
693
|
this.serializer = sdk.serializer;
|
|
981
694
|
this.metadata = metadata;
|
|
982
|
-
|
|
983
|
-
_classPrivateFieldSet(this, _isUnitOfWorkEnabled, isUnitOfWorkEnabled);
|
|
695
|
+
_classPrivateFieldSet2(_isUnitOfWorkEnabled, this, isUnitOfWorkEnabled);
|
|
984
696
|
}
|
|
985
|
-
|
|
986
|
-
_createClass(AbstractClient, [{
|
|
697
|
+
return _createClass(AbstractClient, [{
|
|
987
698
|
key: "withUnitOfWork",
|
|
988
699
|
value: function withUnitOfWork(enabled) {
|
|
989
|
-
// eslint-disable-next-line new-cap
|
|
990
700
|
return generateRepository(this.sdk, this.metadata, enabled);
|
|
991
701
|
}
|
|
992
702
|
}, {
|
|
993
703
|
key: "getDefaultParameters",
|
|
994
704
|
value: function getDefaultParameters() {
|
|
995
705
|
return {};
|
|
996
|
-
}
|
|
706
|
+
}
|
|
997
707
|
|
|
708
|
+
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
998
709
|
}, {
|
|
999
710
|
key: "getPathBase",
|
|
1000
711
|
value: function getPathBase(pathParameters) {
|
|
@@ -1004,11 +715,9 @@
|
|
|
1004
715
|
key: "getEntityURI",
|
|
1005
716
|
value: function getEntityURI(entity) {
|
|
1006
717
|
var idValue = this._getEntityIdentifier(entity);
|
|
1007
|
-
|
|
1008
718
|
if (idValue === null) {
|
|
1009
719
|
throw new Error('Cannot call `getEntityURI for entity without id.`');
|
|
1010
720
|
}
|
|
1011
|
-
|
|
1012
721
|
if (typeof idValue === 'number') {
|
|
1013
722
|
if (Number.isFinite(idValue)) {
|
|
1014
723
|
idValue = idValue.toString();
|
|
@@ -1016,15 +725,13 @@
|
|
|
1016
725
|
throw new Error('Unable to handle non-finite number');
|
|
1017
726
|
}
|
|
1018
727
|
}
|
|
1019
|
-
|
|
1020
728
|
var pathBase = this.getPathBase({});
|
|
1021
|
-
|
|
1022
729
|
if (idValue.indexOf(pathBase) > -1) {
|
|
1023
730
|
return idValue;
|
|
1024
731
|
}
|
|
1025
|
-
|
|
1026
732
|
return "".concat(pathBase, "/").concat(idValue);
|
|
1027
733
|
}
|
|
734
|
+
|
|
1028
735
|
/**
|
|
1029
736
|
* get an entity by its id
|
|
1030
737
|
*
|
|
@@ -1033,18 +740,16 @@
|
|
|
1033
740
|
* @param {Record<string, unknown>} pathParameters path parameters, will be pass to the `getPathBase` method
|
|
1034
741
|
* @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
|
|
1035
742
|
*/
|
|
1036
|
-
|
|
1037
743
|
}, {
|
|
1038
744
|
key: "find",
|
|
1039
745
|
value: function find(id) {
|
|
1040
746
|
var queryParam = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
1041
747
|
var pathParameters = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
1042
748
|
var requestParams = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
|
|
1043
|
-
|
|
1044
749
|
var url = this._generateUrlFromParams(queryParam, pathParameters, id);
|
|
1045
|
-
|
|
1046
750
|
return this.deserializeResponse(this.authorizedFetch(url, requestParams), 'item');
|
|
1047
751
|
}
|
|
752
|
+
|
|
1048
753
|
/**
|
|
1049
754
|
* get a list of entities by some parameters
|
|
1050
755
|
*
|
|
@@ -1052,17 +757,15 @@
|
|
|
1052
757
|
* @param {Record<string, unknown>} pathParameters path parameters, will be pass to the `getPathBase` method
|
|
1053
758
|
* @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
|
|
1054
759
|
*/
|
|
1055
|
-
|
|
1056
760
|
}, {
|
|
1057
761
|
key: "findBy",
|
|
1058
762
|
value: function findBy(queryParam) {
|
|
1059
763
|
var pathParameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
1060
764
|
var requestParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
1061
|
-
|
|
1062
765
|
var url = this._generateUrlFromParams(queryParam, pathParameters);
|
|
1063
|
-
|
|
1064
766
|
return this.deserializeResponse(this.authorizedFetch(url, requestParams), 'list');
|
|
1065
767
|
}
|
|
768
|
+
|
|
1066
769
|
/**
|
|
1067
770
|
* get a list of all entities
|
|
1068
771
|
*
|
|
@@ -1070,7 +773,6 @@
|
|
|
1070
773
|
* @param {Record<string, unknown>} pathParameters path parameters, will be pass to the `getPathBase` method
|
|
1071
774
|
* @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
|
|
1072
775
|
*/
|
|
1073
|
-
|
|
1074
776
|
}, {
|
|
1075
777
|
key: "findAll",
|
|
1076
778
|
value: function findAll() {
|
|
@@ -1079,6 +781,7 @@
|
|
|
1079
781
|
var requestParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
1080
782
|
return this.findBy(queryParam, pathParameters, requestParams);
|
|
1081
783
|
}
|
|
784
|
+
|
|
1082
785
|
/**
|
|
1083
786
|
* create an entity
|
|
1084
787
|
*
|
|
@@ -1087,7 +790,6 @@
|
|
|
1087
790
|
* @param {Record<string, unknown>} pathParameters path parameters, will be pass to the `getPathBase` method
|
|
1088
791
|
* @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
|
|
1089
792
|
*/
|
|
1090
|
-
|
|
1091
793
|
}, {
|
|
1092
794
|
key: "create",
|
|
1093
795
|
value: function create(entity) {
|
|
@@ -1104,6 +806,7 @@
|
|
|
1104
806
|
body: this.serializer.encodeItem(diff, this.metadata)
|
|
1105
807
|
}, requestParams)), 'item');
|
|
1106
808
|
}
|
|
809
|
+
|
|
1107
810
|
/**
|
|
1108
811
|
* update an entity
|
|
1109
812
|
*
|
|
@@ -1111,57 +814,69 @@
|
|
|
1111
814
|
* @param {Record<string, unknown>} queryParam query parameters that will be added to the request
|
|
1112
815
|
* @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
|
|
1113
816
|
*/
|
|
1114
|
-
|
|
1115
817
|
}, {
|
|
1116
818
|
key: "update",
|
|
1117
819
|
value: function update(entity) {
|
|
1118
820
|
var queryParam = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
1119
821
|
var requestParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
822
|
+
return this._update('PUT', entity, queryParam, requestParams);
|
|
823
|
+
}
|
|
824
|
+
|
|
825
|
+
/**
|
|
826
|
+
* partially update an entity using the `PATCH` HTTP verb
|
|
827
|
+
*
|
|
828
|
+
* @param {Record<string, unknown>} entity the entity to update
|
|
829
|
+
* @param {Record<string, unknown>} queryParam query parameters that will be added to the request
|
|
830
|
+
* @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
|
|
831
|
+
*/
|
|
832
|
+
}, {
|
|
833
|
+
key: "patch",
|
|
834
|
+
value: function patch(entity) {
|
|
835
|
+
var queryParam = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
836
|
+
var requestParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
837
|
+
return this._update('PATCH', entity, queryParam, requestParams);
|
|
838
|
+
}
|
|
839
|
+
}, {
|
|
840
|
+
key: "_update",
|
|
841
|
+
value: function _update(method, entity) {
|
|
842
|
+
var queryParam = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
843
|
+
var requestParams = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
|
|
1120
844
|
var url = new URI(this.getEntityURI(entity));
|
|
1121
845
|
url.addSearch(queryParam);
|
|
1122
846
|
var newSerializedModel = this.serializer.normalizeItem(entity, this.metadata);
|
|
1123
|
-
|
|
1124
847
|
var identifier = this._getEntityIdentifier(newSerializedModel);
|
|
1125
|
-
|
|
1126
848
|
var oldModel;
|
|
1127
|
-
|
|
1128
849
|
if (identifier !== null) {
|
|
1129
850
|
oldModel = this.sdk.unitOfWork.getDirtyEntity(identifier);
|
|
1130
851
|
}
|
|
1131
|
-
|
|
1132
852
|
if (oldModel) {
|
|
1133
853
|
newSerializedModel = this.sdk.unitOfWork.getDirtyData(newSerializedModel, oldModel, this.metadata);
|
|
1134
854
|
}
|
|
1135
|
-
|
|
1136
855
|
return this.deserializeResponse(this.authorizedFetch(url, _objectSpread2({
|
|
1137
|
-
method:
|
|
856
|
+
method: method,
|
|
1138
857
|
body: this.serializer.encodeItem(newSerializedModel, this.metadata)
|
|
1139
858
|
}, requestParams)), 'item');
|
|
1140
859
|
}
|
|
860
|
+
|
|
1141
861
|
/**
|
|
1142
862
|
* delete an entity
|
|
1143
863
|
*
|
|
1144
864
|
* @param {Record<string, unknown>} the entity to delete
|
|
1145
865
|
* @param {Record<string, unknown>} requestParams parameters that will be send as second parameter to the `fetch` call
|
|
1146
866
|
*/
|
|
1147
|
-
|
|
1148
867
|
}, {
|
|
1149
868
|
key: "delete",
|
|
1150
869
|
value: function _delete(entity) {
|
|
1151
870
|
var _this = this;
|
|
1152
|
-
|
|
1153
871
|
var requestParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
1154
872
|
var url = this.getEntityURI(entity);
|
|
1155
|
-
|
|
1156
873
|
var identifier = this._getEntityIdentifier(entity);
|
|
1157
|
-
|
|
1158
874
|
return this.authorizedFetch(url, _objectSpread2({
|
|
1159
875
|
method: 'DELETE'
|
|
1160
876
|
}, requestParams)).then(function (response) {
|
|
1161
877
|
if (identifier !== null) {
|
|
1162
878
|
_this.sdk.unitOfWork.clear(identifier);
|
|
1163
879
|
}
|
|
1164
|
-
|
|
1165
880
|
return response;
|
|
1166
881
|
});
|
|
1167
882
|
}
|
|
@@ -1169,7 +884,6 @@
|
|
|
1169
884
|
key: "deserializeResponse",
|
|
1170
885
|
value: function deserializeResponse(requestPromise, listOrItem) {
|
|
1171
886
|
var _this2 = this;
|
|
1172
|
-
|
|
1173
887
|
return requestPromise.then(function (response) {
|
|
1174
888
|
return response.text().then(function (text) {
|
|
1175
889
|
return {
|
|
@@ -1179,26 +893,20 @@
|
|
|
1179
893
|
});
|
|
1180
894
|
}).then(function (_ref) {
|
|
1181
895
|
var response = _ref.response,
|
|
1182
|
-
|
|
1183
|
-
|
|
896
|
+
text = _ref.text;
|
|
1184
897
|
if (listOrItem === 'list') {
|
|
1185
898
|
// for list, we need to deserialize the result to get an object
|
|
1186
899
|
var itemList = _this2.serializer.deserializeList(text, _this2.metadata, response);
|
|
1187
|
-
|
|
1188
|
-
if (_classPrivateFieldGet(_this2, _isUnitOfWorkEnabled)) {
|
|
1189
|
-
// eslint-disable-next-line no-restricted-syntax
|
|
900
|
+
if (_classPrivateFieldGet2(_isUnitOfWorkEnabled, _this2)) {
|
|
1190
901
|
var _iterator = _createForOfIteratorHelper(itemList),
|
|
1191
|
-
|
|
1192
|
-
|
|
902
|
+
_step;
|
|
1193
903
|
try {
|
|
1194
904
|
for (_iterator.s(); !(_step = _iterator.n()).done;) {
|
|
1195
905
|
var _decodedItem = _step.value;
|
|
1196
|
-
|
|
1197
906
|
var _identifier = _this2._getEntityIdentifier(_decodedItem);
|
|
907
|
+
var normalizedItem = _this2.serializer.normalizeItem(_decodedItem, _this2.metadata);
|
|
1198
908
|
|
|
1199
|
-
|
|
1200
|
-
|
|
1201
|
-
|
|
909
|
+
// then we register the re-normalized item
|
|
1202
910
|
if (_identifier !== null) {
|
|
1203
911
|
_this2.sdk.unitOfWork.registerClean(_identifier, normalizedItem);
|
|
1204
912
|
}
|
|
@@ -1209,23 +917,20 @@
|
|
|
1209
917
|
_iterator.f();
|
|
1210
918
|
}
|
|
1211
919
|
}
|
|
1212
|
-
|
|
1213
920
|
return itemList;
|
|
1214
|
-
}
|
|
1215
|
-
|
|
1216
|
-
|
|
1217
|
-
var decodedItem = _this2.serializer.decodeItem(text, _this2.metadata, response); // and register it directy without deserializing + renormalizing
|
|
1218
|
-
|
|
921
|
+
}
|
|
1219
922
|
|
|
1220
|
-
|
|
923
|
+
// for items, we can just decode the item (ie. transform it to JS object)
|
|
924
|
+
var decodedItem = _this2.serializer.decodeItem(text, _this2.metadata, response);
|
|
1221
925
|
|
|
926
|
+
// and register it directy without deserializing + renormalizing
|
|
927
|
+
var identifier = _this2._getEntityIdentifier(decodedItem);
|
|
1222
928
|
|
|
929
|
+
// and finally return the denormalized item
|
|
1223
930
|
var item = _this2.serializer.denormalizeItem(decodedItem, _this2.metadata, response);
|
|
1224
|
-
|
|
1225
|
-
if (_classPrivateFieldGet(_this2, _isUnitOfWorkEnabled) && identifier !== null) {
|
|
931
|
+
if (_classPrivateFieldGet2(_isUnitOfWorkEnabled, _this2) && identifier !== null) {
|
|
1226
932
|
_this2.sdk.unitOfWork.registerClean(identifier, _this2.serializer.normalizeItem(item, _this2.metadata));
|
|
1227
933
|
}
|
|
1228
|
-
|
|
1229
934
|
return item;
|
|
1230
935
|
});
|
|
1231
936
|
}
|
|
@@ -1234,20 +939,16 @@
|
|
|
1234
939
|
value: function makeUri(input) {
|
|
1235
940
|
var url = input instanceof URI ? input : new URI(input);
|
|
1236
941
|
url.host(this.sdk.config.path).scheme(this.sdk.config.scheme);
|
|
1237
|
-
|
|
1238
942
|
if (this.sdk.config.port) {
|
|
1239
943
|
url.port(String(this.sdk.config.port));
|
|
1240
944
|
}
|
|
1241
|
-
|
|
1242
945
|
if (this.sdk.mapping.idPrefix) {
|
|
1243
946
|
var segments = url.segment();
|
|
1244
|
-
|
|
1245
947
|
if (!url.pathname().startsWith(this.sdk.mapping.idPrefix)) {
|
|
1246
948
|
segments.unshift(this.sdk.mapping.idPrefix);
|
|
1247
949
|
url.segment(segments);
|
|
1248
950
|
}
|
|
1249
951
|
}
|
|
1250
|
-
|
|
1251
952
|
return url;
|
|
1252
953
|
}
|
|
1253
954
|
}, {
|
|
@@ -1263,17 +964,13 @@
|
|
|
1263
964
|
var pathParameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
1264
965
|
var id = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
|
|
1265
966
|
var params = queryParam;
|
|
1266
|
-
|
|
1267
967
|
if (this.sdk.config.useDefaultParameters) {
|
|
1268
968
|
Object.assign(params, this.getDefaultParameters());
|
|
1269
969
|
}
|
|
1270
|
-
|
|
1271
970
|
var pathBase = this.getPathBase(pathParameters);
|
|
1272
|
-
var url
|
|
1273
|
-
|
|
971
|
+
var url;
|
|
1274
972
|
if (id) {
|
|
1275
973
|
var testPathBase = this.sdk.mapping.idPrefix ? "".concat(this.sdk.mapping.idPrefix).concat(pathBase) : pathBase;
|
|
1276
|
-
|
|
1277
974
|
if (typeof id === 'string' && id.startsWith(testPathBase)) {
|
|
1278
975
|
url = new URI(id);
|
|
1279
976
|
} else {
|
|
@@ -1282,63 +979,51 @@
|
|
|
1282
979
|
} else {
|
|
1283
980
|
url = new URI(pathBase);
|
|
1284
981
|
}
|
|
1285
|
-
|
|
1286
982
|
if (params) {
|
|
1287
983
|
url.addSearch(params);
|
|
1288
984
|
}
|
|
1289
|
-
|
|
1290
985
|
return url;
|
|
1291
986
|
}
|
|
1292
987
|
}, {
|
|
1293
988
|
key: "_fetchWithToken",
|
|
1294
989
|
value: function _fetchWithToken(input) {
|
|
1295
990
|
var _this3 = this;
|
|
1296
|
-
|
|
1297
991
|
var requestParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
1298
|
-
|
|
1299
992
|
if (!input) {
|
|
1300
993
|
throw new Error('input is empty');
|
|
1301
994
|
}
|
|
1302
|
-
|
|
1303
|
-
|
|
1304
|
-
return _classPrivateFieldGet(this, _tokenStorage).getCurrentTokenExpiresIn().then(function (accessTokenExpiresIn) {
|
|
995
|
+
if (_classPrivateFieldGet2(_tokenStorage, this)) {
|
|
996
|
+
return _classPrivateFieldGet2(_tokenStorage, this).getCurrentTokenExpiresIn().then(function (accessTokenExpiresIn) {
|
|
1305
997
|
if (accessTokenExpiresIn !== null && accessTokenExpiresIn <= EXPIRE_LIMIT_SECONDS) {
|
|
1306
|
-
return
|
|
998
|
+
return _classPrivateFieldGet2(_tokenStorage, _this3).refreshToken().then(function (refreshedTokenObject) {
|
|
1307
999
|
return refreshedTokenObject.access_token;
|
|
1308
1000
|
})["catch"](function (e) {
|
|
1309
1001
|
_this3._handleRefreshTokenFailure(e);
|
|
1310
|
-
|
|
1311
1002
|
throw e;
|
|
1312
1003
|
});
|
|
1313
1004
|
}
|
|
1314
|
-
|
|
1315
|
-
return _classPrivateFieldGet(_this3, _tokenStorage).getAccessToken();
|
|
1005
|
+
return _classPrivateFieldGet2(_tokenStorage, _this3).getAccessToken();
|
|
1316
1006
|
}).then(function (token) {
|
|
1317
1007
|
return _this3._doFetch(token, input, requestParams);
|
|
1318
1008
|
});
|
|
1319
1009
|
}
|
|
1320
|
-
|
|
1321
1010
|
return this._doFetch(null, input, requestParams);
|
|
1322
1011
|
}
|
|
1323
1012
|
}, {
|
|
1324
1013
|
key: "_refreshTokenAndRefetch",
|
|
1325
1014
|
value: function _refreshTokenAndRefetch(input) {
|
|
1326
1015
|
var _this4 = this;
|
|
1327
|
-
|
|
1328
1016
|
var requestParams = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
1329
|
-
return
|
|
1017
|
+
return _classPrivateFieldGet2(_tokenStorage, this).refreshToken().then(function () {
|
|
1330
1018
|
// eslint-disable-next-line prefer-const
|
|
1331
1019
|
var headers = requestParams.headers,
|
|
1332
|
-
|
|
1333
|
-
|
|
1020
|
+
rest = _objectWithoutProperties(requestParams, _excluded);
|
|
1334
1021
|
var updatedRequestParams = _objectSpread2(_objectSpread2({}, rest), {}, {
|
|
1335
1022
|
headers: removeAuthorization(headers)
|
|
1336
1023
|
});
|
|
1337
|
-
|
|
1338
1024
|
return _this4._fetchWithToken(input, updatedRequestParams);
|
|
1339
1025
|
})["catch"](function (e) {
|
|
1340
1026
|
_this4._handleRefreshTokenFailure(e);
|
|
1341
|
-
|
|
1342
1027
|
throw e;
|
|
1343
1028
|
});
|
|
1344
1029
|
}
|
|
@@ -1346,33 +1031,28 @@
|
|
|
1346
1031
|
key: "_manageUnauthorized",
|
|
1347
1032
|
value: function _manageUnauthorized(response, input) {
|
|
1348
1033
|
var _this5 = this;
|
|
1349
|
-
|
|
1350
1034
|
var requestParams = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
1351
|
-
var error = getHttpErrorFromResponse(response);
|
|
1035
|
+
var error = getHttpErrorFromResponse(response);
|
|
1352
1036
|
|
|
1037
|
+
// https://tools.ietf.org/html/rfc2617#section-1.2
|
|
1353
1038
|
var authorizationHeader = response.headers.get('www-authenticate');
|
|
1354
|
-
|
|
1355
1039
|
if (authorizationHeader) {
|
|
1356
1040
|
var invalidGrant = authorizationHeader.indexOf('error="invalid_grant"') > -1;
|
|
1357
|
-
|
|
1358
|
-
if (invalidGrant && _classPrivateFieldGet(this, _tokenStorage)) {
|
|
1041
|
+
if (invalidGrant && _classPrivateFieldGet2(_tokenStorage, this)) {
|
|
1359
1042
|
return this._refreshTokenAndRefetch(input, requestParams);
|
|
1360
1043
|
}
|
|
1361
|
-
|
|
1362
1044
|
throw error;
|
|
1363
1045
|
} else {
|
|
1364
1046
|
// if www-authenticate header is missing, try and read json response
|
|
1365
1047
|
return response.json().then(function (body) {
|
|
1366
|
-
if (
|
|
1048
|
+
if (_classPrivateFieldGet2(_tokenStorage, _this5) && (body.error === 'invalid_scope' || body.error === 'access_denied')) {
|
|
1367
1049
|
return _this5._refreshTokenAndRefetch(input, requestParams);
|
|
1368
1050
|
}
|
|
1369
|
-
|
|
1370
1051
|
throw error;
|
|
1371
1052
|
})["catch"](function (err) {
|
|
1372
1053
|
if (err instanceof OauthError) {
|
|
1373
1054
|
throw err;
|
|
1374
1055
|
}
|
|
1375
|
-
|
|
1376
1056
|
throw error;
|
|
1377
1057
|
});
|
|
1378
1058
|
}
|
|
@@ -1381,58 +1061,45 @@
|
|
|
1381
1061
|
key: "_doFetch",
|
|
1382
1062
|
value: function _doFetch(accessToken, input, requestParams) {
|
|
1383
1063
|
var _this6 = this;
|
|
1384
|
-
|
|
1385
1064
|
var params = requestParams;
|
|
1386
1065
|
var baseHeaders = {};
|
|
1387
|
-
|
|
1388
1066
|
if (params.method !== 'GET' || params.method !== 'GET' && params.method !== 'DELETE') {
|
|
1389
1067
|
baseHeaders = {
|
|
1390
1068
|
'Content-Type': 'application/json'
|
|
1391
1069
|
};
|
|
1392
1070
|
}
|
|
1393
|
-
|
|
1394
1071
|
if (accessToken) {
|
|
1395
1072
|
baseHeaders.Authorization = "".concat(this.sdk.config.authorizationType, " ").concat(accessToken);
|
|
1396
1073
|
}
|
|
1397
|
-
|
|
1398
1074
|
if (params) {
|
|
1399
1075
|
if (!params.headers) {
|
|
1400
1076
|
params.headers = {};
|
|
1401
1077
|
}
|
|
1402
|
-
|
|
1403
1078
|
params.headers = Object.assign(baseHeaders, params.headers);
|
|
1404
1079
|
} else {
|
|
1405
1080
|
params = {
|
|
1406
1081
|
headers: baseHeaders
|
|
1407
1082
|
};
|
|
1408
1083
|
}
|
|
1409
|
-
|
|
1410
1084
|
if (params.headers) {
|
|
1411
1085
|
params.headers = removeUndefinedHeaders(params.headers);
|
|
1412
1086
|
}
|
|
1413
|
-
|
|
1414
1087
|
var logId;
|
|
1415
|
-
|
|
1416
1088
|
if (this.sdk.logger) {
|
|
1417
1089
|
logId = this.sdk.logger.logRequest(_objectSpread2({
|
|
1418
1090
|
url: input
|
|
1419
1091
|
}, params));
|
|
1420
|
-
}
|
|
1421
|
-
|
|
1422
|
-
|
|
1092
|
+
}
|
|
1423
1093
|
return fetch(input, params).then(function (response) {
|
|
1424
1094
|
if (_this6.sdk.logger) {
|
|
1425
1095
|
_this6.sdk.logger.logResponse(response, logId);
|
|
1426
1096
|
}
|
|
1427
|
-
|
|
1428
1097
|
if (response.status < 400) {
|
|
1429
1098
|
return response;
|
|
1430
1099
|
}
|
|
1431
|
-
|
|
1432
1100
|
if (response.status === 401) {
|
|
1433
1101
|
return _this6._manageUnauthorized(response, input, params);
|
|
1434
1102
|
}
|
|
1435
|
-
|
|
1436
1103
|
var httpError = getHttpErrorFromResponse(response);
|
|
1437
1104
|
throw httpError;
|
|
1438
1105
|
});
|
|
@@ -1440,18 +1107,18 @@
|
|
|
1440
1107
|
}, {
|
|
1441
1108
|
key: "_getEntityIdentifier",
|
|
1442
1109
|
value: function _getEntityIdentifier(object) {
|
|
1443
|
-
var idKey = this.metadata.getIdentifierAttribute().serializedKey;
|
|
1444
|
-
// @ts-ignore
|
|
1110
|
+
var idKey = this.metadata.getIdentifierAttribute().serializedKey;
|
|
1445
1111
|
|
|
1112
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
1113
|
+
// @ts-ignore
|
|
1446
1114
|
return object[idKey];
|
|
1447
1115
|
}
|
|
1448
1116
|
}, {
|
|
1449
1117
|
key: "_handleRefreshTokenFailure",
|
|
1450
1118
|
value: function _handleRefreshTokenFailure(error) {
|
|
1451
1119
|
var _this7 = this;
|
|
1452
|
-
|
|
1453
1120
|
if (error instanceof OauthError) {
|
|
1454
|
-
|
|
1121
|
+
_classPrivateFieldGet2(_tokenStorage, this).logout().then(function () {
|
|
1455
1122
|
if (_this7.sdk.config.onRefreshTokenFailure) {
|
|
1456
1123
|
_this7.sdk.config.onRefreshTokenFailure(error);
|
|
1457
1124
|
}
|
|
@@ -1459,16 +1126,11 @@
|
|
|
1459
1126
|
}
|
|
1460
1127
|
}
|
|
1461
1128
|
}]);
|
|
1462
|
-
|
|
1463
|
-
return AbstractClient;
|
|
1464
1129
|
}();
|
|
1465
1130
|
|
|
1466
|
-
var _attributeList = new WeakMap();
|
|
1467
|
-
|
|
1468
|
-
var
|
|
1469
|
-
|
|
1470
|
-
var _identifierAttribute = new WeakMap();
|
|
1471
|
-
|
|
1131
|
+
var _attributeList = /*#__PURE__*/new WeakMap();
|
|
1132
|
+
var _relationList = /*#__PURE__*/new WeakMap();
|
|
1133
|
+
var _identifierAttribute = /*#__PURE__*/new WeakMap();
|
|
1472
1134
|
var ClassMetadata = /*#__PURE__*/function () {
|
|
1473
1135
|
/**
|
|
1474
1136
|
* @param {string} key mandatory, will be passed in your serializer
|
|
@@ -1478,86 +1140,59 @@
|
|
|
1478
1140
|
function ClassMetadata(key) {
|
|
1479
1141
|
var pathRoot = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
1480
1142
|
var repositoryClass = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : AbstractClient;
|
|
1481
|
-
|
|
1482
1143
|
_classCallCheck(this, ClassMetadata);
|
|
1483
|
-
|
|
1484
1144
|
_defineProperty(this, "key", void 0);
|
|
1485
|
-
|
|
1486
1145
|
_defineProperty(this, "pathRoot", void 0);
|
|
1487
|
-
|
|
1488
1146
|
_defineProperty(this, "repositoryClass", void 0);
|
|
1489
|
-
|
|
1490
|
-
|
|
1491
|
-
|
|
1492
|
-
value: void 0
|
|
1493
|
-
});
|
|
1494
|
-
|
|
1495
|
-
_relationList.set(this, {
|
|
1496
|
-
writable: true,
|
|
1497
|
-
value: void 0
|
|
1498
|
-
});
|
|
1499
|
-
|
|
1500
|
-
_identifierAttribute.set(this, {
|
|
1501
|
-
writable: true,
|
|
1502
|
-
value: void 0
|
|
1503
|
-
});
|
|
1504
|
-
|
|
1147
|
+
_classPrivateFieldInitSpec(this, _attributeList, void 0);
|
|
1148
|
+
_classPrivateFieldInitSpec(this, _relationList, void 0);
|
|
1149
|
+
_classPrivateFieldInitSpec(this, _identifierAttribute, void 0);
|
|
1505
1150
|
if (!key) {
|
|
1506
1151
|
throw new TypeError('key attribute are required');
|
|
1507
1152
|
}
|
|
1508
|
-
|
|
1509
1153
|
this.key = key;
|
|
1510
|
-
this.pathRoot = pathRoot || key;
|
|
1511
|
-
|
|
1154
|
+
this.pathRoot = pathRoot || key;
|
|
1155
|
+
// this.modelName = modelName;
|
|
1512
1156
|
this.repositoryClass = repositoryClass;
|
|
1513
|
-
|
|
1514
|
-
|
|
1515
|
-
|
|
1516
|
-
_classPrivateFieldSet(this, _relationList, {});
|
|
1157
|
+
_classPrivateFieldSet2(_attributeList, this, {});
|
|
1158
|
+
_classPrivateFieldSet2(_relationList, this, {});
|
|
1517
1159
|
}
|
|
1518
|
-
|
|
1519
|
-
_createClass(ClassMetadata, [{
|
|
1160
|
+
return _createClass(ClassMetadata, [{
|
|
1520
1161
|
key: "getAttribute",
|
|
1521
1162
|
value: function getAttribute(name) {
|
|
1522
|
-
return
|
|
1163
|
+
return _classPrivateFieldGet2(_attributeList, this)[name];
|
|
1523
1164
|
}
|
|
1524
1165
|
}, {
|
|
1525
1166
|
key: "hasIdentifierAttribute",
|
|
1526
1167
|
value: function hasIdentifierAttribute() {
|
|
1527
|
-
return !!
|
|
1168
|
+
return !!_classPrivateFieldGet2(_identifierAttribute, this);
|
|
1528
1169
|
}
|
|
1529
1170
|
}, {
|
|
1530
1171
|
key: "getIdentifierAttribute",
|
|
1531
1172
|
value: function getIdentifierAttribute() {
|
|
1532
|
-
if (!
|
|
1173
|
+
if (!_classPrivateFieldGet2(_identifierAttribute, this)) {
|
|
1533
1174
|
throw new TypeError("\"".concat(this.key, "\" has no identifier attribute set. Did you call \"setAttributeList\" first ?"));
|
|
1534
1175
|
}
|
|
1535
|
-
|
|
1536
|
-
return _classPrivateFieldGet(this, _identifierAttribute);
|
|
1176
|
+
return _classPrivateFieldGet2(_identifierAttribute, this);
|
|
1537
1177
|
}
|
|
1538
1178
|
}, {
|
|
1539
1179
|
key: "getAttributeList",
|
|
1540
1180
|
value: function getAttributeList() {
|
|
1541
|
-
return
|
|
1181
|
+
return _classPrivateFieldGet2(_attributeList, this);
|
|
1542
1182
|
}
|
|
1543
1183
|
}, {
|
|
1544
1184
|
key: "setAttributeList",
|
|
1545
1185
|
value: function setAttributeList(attributeList) {
|
|
1546
1186
|
var _this = this;
|
|
1547
|
-
|
|
1548
|
-
|
|
1549
|
-
|
|
1550
|
-
_classPrivateFieldSet(this, _identifierAttribute, undefined);
|
|
1551
|
-
|
|
1187
|
+
_classPrivateFieldSet2(_attributeList, this, {});
|
|
1188
|
+
_classPrivateFieldSet2(_identifierAttribute, this, undefined);
|
|
1552
1189
|
attributeList.forEach(function (attribute) {
|
|
1553
|
-
|
|
1554
|
-
|
|
1190
|
+
_classPrivateFieldGet2(_attributeList, _this)[attribute.serializedKey] = attribute;
|
|
1555
1191
|
if (attribute.isIdentifier) {
|
|
1556
|
-
|
|
1192
|
+
_classPrivateFieldSet2(_identifierAttribute, _this, attribute);
|
|
1557
1193
|
}
|
|
1558
1194
|
});
|
|
1559
|
-
|
|
1560
|
-
if (!_classPrivateFieldGet(this, _identifierAttribute)) {
|
|
1195
|
+
if (!_classPrivateFieldGet2(_identifierAttribute, this)) {
|
|
1561
1196
|
throw new TypeError("\"".concat(this.key, "\" has no identifier attribute set. You must set all your attributes in one time and send an attribute with \"isIdentifier=true\""));
|
|
1562
1197
|
}
|
|
1563
1198
|
}
|
|
@@ -1565,31 +1200,27 @@
|
|
|
1565
1200
|
key: "setRelationList",
|
|
1566
1201
|
value: function setRelationList(relationList) {
|
|
1567
1202
|
var _this2 = this;
|
|
1568
|
-
|
|
1569
|
-
_classPrivateFieldSet(this, _relationList, {});
|
|
1570
|
-
|
|
1203
|
+
_classPrivateFieldSet2(_relationList, this, {});
|
|
1571
1204
|
relationList.forEach(function (relation) {
|
|
1572
|
-
|
|
1573
|
-
|
|
1205
|
+
_classPrivateFieldGet2(_relationList, _this2)[relation.serializedKey] = relation;
|
|
1206
|
+
_classPrivateFieldGet2(_attributeList, _this2)[relation.serializedKey] = new Attribute(relation.serializedKey, relation.serializedKey, relation.isRelationToMany() ? 'array' : 'object');
|
|
1574
1207
|
});
|
|
1575
1208
|
}
|
|
1576
1209
|
}, {
|
|
1577
1210
|
key: "getRelation",
|
|
1578
1211
|
value: function getRelation(key) {
|
|
1579
|
-
return
|
|
1212
|
+
return _classPrivateFieldGet2(_relationList, this)[key];
|
|
1580
1213
|
}
|
|
1581
1214
|
}, {
|
|
1582
1215
|
key: "getDefaultSerializedModel",
|
|
1583
1216
|
value: function getDefaultSerializedModel() {
|
|
1584
1217
|
var _this3 = this;
|
|
1585
|
-
|
|
1586
1218
|
var out = {};
|
|
1587
|
-
Object.keys(
|
|
1219
|
+
Object.keys(_classPrivateFieldGet2(_attributeList, this)).forEach(function (serializedKey) {
|
|
1588
1220
|
out[serializedKey] = null;
|
|
1589
1221
|
});
|
|
1590
|
-
Object.keys(
|
|
1591
|
-
var relation =
|
|
1592
|
-
|
|
1222
|
+
Object.keys(_classPrivateFieldGet2(_relationList, this)).forEach(function (serializedKey) {
|
|
1223
|
+
var relation = _classPrivateFieldGet2(_relationList, _this3)[serializedKey];
|
|
1593
1224
|
if (relation.isRelationToMany()) {
|
|
1594
1225
|
out[serializedKey] = [];
|
|
1595
1226
|
}
|
|
@@ -1597,19 +1228,15 @@
|
|
|
1597
1228
|
return out;
|
|
1598
1229
|
}
|
|
1599
1230
|
}]);
|
|
1600
|
-
|
|
1601
|
-
return ClassMetadata;
|
|
1602
1231
|
}();
|
|
1603
1232
|
|
|
1604
|
-
var RelationTypes
|
|
1605
|
-
|
|
1606
|
-
(function (RelationTypes) {
|
|
1233
|
+
var RelationTypes = /*#__PURE__*/function (RelationTypes) {
|
|
1607
1234
|
RelationTypes["ONE_TO_ONE"] = "ONE_TO_ONE";
|
|
1608
1235
|
RelationTypes["ONE_TO_MANY"] = "ONE_TO_MANY";
|
|
1609
1236
|
RelationTypes["MANY_TO_MANY"] = "MANY_TO_MANY";
|
|
1610
1237
|
RelationTypes["MANY_TO_ONE"] = "MANY_TO_ONE";
|
|
1611
|
-
|
|
1612
|
-
|
|
1238
|
+
return RelationTypes;
|
|
1239
|
+
}(RelationTypes || {});
|
|
1613
1240
|
var Relation = /*#__PURE__*/function () {
|
|
1614
1241
|
/**
|
|
1615
1242
|
* @param {RelationTypes} type the type of relation
|
|
@@ -1619,24 +1246,17 @@
|
|
|
1619
1246
|
*/
|
|
1620
1247
|
function Relation(type, targetMetadataKey, serializedKey) {
|
|
1621
1248
|
var attributeName = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
|
|
1622
|
-
|
|
1623
1249
|
_classCallCheck(this, Relation);
|
|
1624
|
-
|
|
1625
1250
|
_defineProperty(this, "type", void 0);
|
|
1626
|
-
|
|
1627
1251
|
_defineProperty(this, "targetMetadataKey", void 0);
|
|
1628
|
-
|
|
1629
1252
|
_defineProperty(this, "serializedKey", void 0);
|
|
1630
|
-
|
|
1631
1253
|
_defineProperty(this, "attributeName", void 0);
|
|
1632
|
-
|
|
1633
1254
|
this.type = type;
|
|
1634
1255
|
this.targetMetadataKey = targetMetadataKey;
|
|
1635
1256
|
this.serializedKey = serializedKey;
|
|
1636
1257
|
this.attributeName = attributeName || this.serializedKey;
|
|
1637
1258
|
}
|
|
1638
|
-
|
|
1639
|
-
_createClass(Relation, [{
|
|
1259
|
+
return _createClass(Relation, [{
|
|
1640
1260
|
key: "isOneToOne",
|
|
1641
1261
|
value: function isOneToOne() {
|
|
1642
1262
|
return this.type === Relation.ONE_TO_ONE;
|
|
@@ -1667,16 +1287,10 @@
|
|
|
1667
1287
|
return this.isManyToOne() || this.isOneToOne();
|
|
1668
1288
|
}
|
|
1669
1289
|
}]);
|
|
1670
|
-
|
|
1671
|
-
return Relation;
|
|
1672
1290
|
}();
|
|
1673
|
-
|
|
1674
1291
|
_defineProperty(Relation, "ONE_TO_ONE", RelationTypes.ONE_TO_ONE);
|
|
1675
|
-
|
|
1676
1292
|
_defineProperty(Relation, "ONE_TO_MANY", RelationTypes.ONE_TO_MANY);
|
|
1677
|
-
|
|
1678
1293
|
_defineProperty(Relation, "MANY_TO_ONE", RelationTypes.MANY_TO_ONE);
|
|
1679
|
-
|
|
1680
1294
|
_defineProperty(Relation, "MANY_TO_MANY", RelationTypes.MANY_TO_MANY);
|
|
1681
1295
|
|
|
1682
1296
|
/* eslint-disable */
|
|
@@ -1689,6 +1303,7 @@
|
|
|
1689
1303
|
* This source code is licensed under the MIT license found in the
|
|
1690
1304
|
* LICENSE file in the root directory of this source tree.
|
|
1691
1305
|
*/
|
|
1306
|
+
|
|
1692
1307
|
var IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
|
|
1693
1308
|
var IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@';
|
|
1694
1309
|
function isImmutable(maybeImmutable) {
|
|
@@ -1708,112 +1323,87 @@
|
|
|
1708
1323
|
var result = diff(left, right);
|
|
1709
1324
|
return result ? result.length > 0 : false;
|
|
1710
1325
|
}
|
|
1326
|
+
|
|
1711
1327
|
/**
|
|
1712
1328
|
* get the id of an entity or return itself if string
|
|
1713
1329
|
*/
|
|
1714
|
-
|
|
1715
|
-
|
|
1716
1330
|
function getEntityId(stringOrEntity, idSerializedKey) {
|
|
1717
1331
|
if (_typeof(stringOrEntity) !== 'object') {
|
|
1718
1332
|
return stringOrEntity;
|
|
1719
|
-
}
|
|
1720
|
-
// @ts-ignore
|
|
1721
|
-
|
|
1333
|
+
}
|
|
1722
1334
|
|
|
1335
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
1336
|
+
// @ts-ignore
|
|
1723
1337
|
return stringOrEntity[idSerializedKey];
|
|
1724
1338
|
}
|
|
1339
|
+
|
|
1725
1340
|
/**
|
|
1726
1341
|
* find old relation value from the new relation id
|
|
1727
1342
|
* if not found, returs the default serilazed model
|
|
1728
1343
|
*/
|
|
1729
|
-
|
|
1730
|
-
|
|
1731
1344
|
function findOldRelation(newRelationValue, oldRelationValue, classMetadata) {
|
|
1732
|
-
var idSerializedKey = classMetadata.getIdentifierAttribute().serializedKey;
|
|
1345
|
+
var idSerializedKey = classMetadata.getIdentifierAttribute().serializedKey;
|
|
1346
|
+
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
|
|
1733
1347
|
// @ts-ignore
|
|
1734
|
-
|
|
1735
1348
|
var relationValueId = getEntityId(newRelationValue, idSerializedKey);
|
|
1736
1349
|
var foundValue = oldRelationValue && oldRelationValue.find(function (innerOldRelationValue) {
|
|
1737
1350
|
var oldRelationValueId = getEntityId(innerOldRelationValue, idSerializedKey);
|
|
1738
1351
|
return relationValueId === oldRelationValueId;
|
|
1739
1352
|
});
|
|
1740
|
-
|
|
1741
1353
|
if (foundValue) {
|
|
1742
1354
|
return foundValue;
|
|
1743
1355
|
}
|
|
1744
|
-
|
|
1745
1356
|
return classMetadata.getDefaultSerializedModel();
|
|
1746
1357
|
}
|
|
1358
|
+
|
|
1747
1359
|
/**
|
|
1748
1360
|
* add all identifier from one to many relation list
|
|
1749
1361
|
*/
|
|
1750
|
-
|
|
1751
|
-
|
|
1752
1362
|
function getIdentifierForList(newValue, idSerializedKey) {
|
|
1753
1363
|
return newValue.map(function (value) {
|
|
1754
1364
|
if (Object.keys(value).includes(idSerializedKey)) {
|
|
1755
1365
|
return _defineProperty({}, idSerializedKey, value[idSerializedKey]);
|
|
1756
1366
|
}
|
|
1757
|
-
|
|
1758
1367
|
if (typeof value === 'string') {
|
|
1759
1368
|
return value;
|
|
1760
1369
|
}
|
|
1761
|
-
|
|
1762
1370
|
throw new TypeError('new value should include a list of string or objects containing the serialized key');
|
|
1763
1371
|
});
|
|
1764
1372
|
}
|
|
1765
|
-
|
|
1766
|
-
var
|
|
1767
|
-
|
|
1768
|
-
var _enabled = new WeakMap();
|
|
1769
|
-
|
|
1373
|
+
var _storage = /*#__PURE__*/new WeakMap();
|
|
1374
|
+
var _enabled = /*#__PURE__*/new WeakMap();
|
|
1770
1375
|
var UnitOfWork = /*#__PURE__*/function () {
|
|
1771
1376
|
function UnitOfWork(mapping) {
|
|
1772
1377
|
var enabled = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
|
|
1773
|
-
|
|
1774
1378
|
_classCallCheck(this, UnitOfWork);
|
|
1775
|
-
|
|
1776
1379
|
_defineProperty(this, "mapping", void 0);
|
|
1777
|
-
|
|
1778
|
-
|
|
1779
|
-
writable: true,
|
|
1780
|
-
value: void 0
|
|
1781
|
-
});
|
|
1782
|
-
|
|
1783
|
-
_enabled.set(this, {
|
|
1784
|
-
writable: true,
|
|
1785
|
-
value: void 0
|
|
1786
|
-
});
|
|
1787
|
-
|
|
1380
|
+
_classPrivateFieldInitSpec(this, _storage, void 0);
|
|
1381
|
+
_classPrivateFieldInitSpec(this, _enabled, void 0);
|
|
1788
1382
|
this.mapping = mapping;
|
|
1789
|
-
|
|
1790
|
-
|
|
1791
|
-
|
|
1792
|
-
_classPrivateFieldSet(this, _storage, {});
|
|
1383
|
+
_classPrivateFieldSet2(_enabled, this, enabled);
|
|
1384
|
+
_classPrivateFieldSet2(_storage, this, {});
|
|
1793
1385
|
}
|
|
1794
|
-
|
|
1795
|
-
_createClass(UnitOfWork, [{
|
|
1386
|
+
return _createClass(UnitOfWork, [{
|
|
1796
1387
|
key: "registerClean",
|
|
1797
1388
|
value: function registerClean(id, entity) {
|
|
1798
|
-
if (!
|
|
1389
|
+
if (!_classPrivateFieldGet2(_enabled, this)) {
|
|
1799
1390
|
return;
|
|
1800
1391
|
}
|
|
1801
|
-
|
|
1802
1392
|
if (isImmutable(entity)) {
|
|
1803
|
-
|
|
1393
|
+
_classPrivateFieldGet2(_storage, this)[id] = entity;
|
|
1804
1394
|
} else {
|
|
1805
|
-
|
|
1395
|
+
_classPrivateFieldGet2(_storage, this)[id] = _objectSpread2({}, entity);
|
|
1806
1396
|
}
|
|
1807
1397
|
}
|
|
1808
1398
|
}, {
|
|
1809
1399
|
key: "getDirtyEntity",
|
|
1810
1400
|
value: function getDirtyEntity(id) {
|
|
1811
|
-
return
|
|
1401
|
+
return _classPrivateFieldGet2(_storage, this)[id];
|
|
1812
1402
|
}
|
|
1813
1403
|
}, {
|
|
1814
1404
|
key: "clear",
|
|
1815
1405
|
value: function clear(id) {
|
|
1816
|
-
delete
|
|
1406
|
+
delete _classPrivateFieldGet2(_storage, this)[id];
|
|
1817
1407
|
}
|
|
1818
1408
|
}, {
|
|
1819
1409
|
key: "getDirtyData",
|
|
@@ -1824,7 +1414,6 @@
|
|
|
1824
1414
|
key: "_getDirtyFieldsForAttribute",
|
|
1825
1415
|
value: function _getDirtyFieldsForAttribute(dirtyFieldsParam, key, attribute, oldValue, newValue) {
|
|
1826
1416
|
var dirtyFields = dirtyFieldsParam;
|
|
1827
|
-
|
|
1828
1417
|
if (attribute.type === 'object' || attribute.type === 'array') {
|
|
1829
1418
|
if (oldValue === undefined || objectDiffers(oldValue, newValue)) {
|
|
1830
1419
|
dirtyFields[key] = newValue;
|
|
@@ -1832,71 +1421,58 @@
|
|
|
1832
1421
|
} else if (oldValue !== newValue) {
|
|
1833
1422
|
dirtyFields[key] = newValue;
|
|
1834
1423
|
}
|
|
1835
|
-
|
|
1836
1424
|
return dirtyFields;
|
|
1837
1425
|
}
|
|
1838
1426
|
}, {
|
|
1839
1427
|
key: "_getDirtyFieldsForManyToOne",
|
|
1840
1428
|
value: function _getDirtyFieldsForManyToOne(dirtyFieldsParam, key, oldValue, newValue, relationMetadata, idSerializedKey) {
|
|
1841
1429
|
var dirtyFields = dirtyFieldsParam;
|
|
1842
|
-
|
|
1843
1430
|
if (oldValue !== newValue) {
|
|
1844
1431
|
if (newValue === null) {
|
|
1845
1432
|
dirtyFields[key] = null;
|
|
1846
1433
|
return dirtyFields;
|
|
1847
1434
|
}
|
|
1848
|
-
|
|
1849
1435
|
if (typeof oldValue === 'string' || typeof newValue === 'string') {
|
|
1850
1436
|
dirtyFields[key] = newValue;
|
|
1851
1437
|
}
|
|
1852
|
-
|
|
1853
1438
|
var recursiveDiff = this._getDirtyFields(newValue, oldValue, relationMetadata);
|
|
1854
|
-
|
|
1855
1439
|
if (Object.keys(recursiveDiff).length > 0) {
|
|
1856
1440
|
recursiveDiff[idSerializedKey] = getEntityId(newValue, idSerializedKey);
|
|
1857
1441
|
dirtyFields[key] = recursiveDiff;
|
|
1858
1442
|
}
|
|
1859
1443
|
}
|
|
1860
|
-
|
|
1861
1444
|
return dirtyFields;
|
|
1862
1445
|
}
|
|
1863
1446
|
}, {
|
|
1864
1447
|
key: "_getDirtyFieldsForOneToMany",
|
|
1865
1448
|
value: function _getDirtyFieldsForOneToMany(dirtyFieldsParam, key, idSerializedKey, relationMetadata, oldValue, newValue) {
|
|
1866
1449
|
var _this = this;
|
|
1867
|
-
|
|
1868
1450
|
var dirtyFields = dirtyFieldsParam;
|
|
1869
1451
|
var newValueLength = newValue ? newValue.length : 0;
|
|
1870
|
-
var oldValueLength = oldValue ? oldValue.length : 0;
|
|
1452
|
+
var oldValueLength = oldValue ? oldValue.length : 0;
|
|
1871
1453
|
|
|
1454
|
+
// number of items changed
|
|
1872
1455
|
if (newValueLength !== oldValueLength) {
|
|
1873
1456
|
dirtyFields[key] = getIdentifierForList(newValue, idSerializedKey);
|
|
1874
1457
|
}
|
|
1875
|
-
|
|
1876
1458
|
if (newValue && newValue.length > 0) {
|
|
1877
1459
|
if (dirtyFields[key] === undefined) {
|
|
1878
1460
|
dirtyFields[key] = [];
|
|
1879
1461
|
}
|
|
1880
|
-
|
|
1881
1462
|
var relationList = newValue;
|
|
1882
1463
|
relationList.forEach(function (newRelationValue, relationAttributeName) {
|
|
1883
1464
|
var oldRelationValue = findOldRelation(newRelationValue, oldValue, relationMetadata);
|
|
1884
|
-
|
|
1885
1465
|
if (newRelationValue !== oldRelationValue) {
|
|
1886
1466
|
if (typeof newRelationValue === 'string' || typeof oldRelationValue === 'string') {
|
|
1887
1467
|
dirtyFields[key][relationAttributeName] = newRelationValue;
|
|
1888
1468
|
return;
|
|
1889
1469
|
}
|
|
1890
|
-
|
|
1891
1470
|
var recursiveDiff = _this._getDirtyFields(newRelationValue, oldRelationValue, relationMetadata);
|
|
1892
|
-
|
|
1893
1471
|
if (Object.keys(recursiveDiff).length > 0) {
|
|
1894
1472
|
var entityId = getEntityId(newRelationValue, idSerializedKey);
|
|
1895
|
-
|
|
1896
1473
|
if (entityId !== null) {
|
|
1897
1474
|
recursiveDiff[idSerializedKey] = entityId;
|
|
1898
1475
|
}
|
|
1899
|
-
|
|
1900
1476
|
if (dirtyFields[key][relationAttributeName]) {
|
|
1901
1477
|
Object.assign(dirtyFields[key][relationAttributeName], recursiveDiff);
|
|
1902
1478
|
} else {
|
|
@@ -1905,7 +1481,6 @@
|
|
|
1905
1481
|
}
|
|
1906
1482
|
}
|
|
1907
1483
|
});
|
|
1908
|
-
|
|
1909
1484
|
if (dirtyFields[key].length > 0) {
|
|
1910
1485
|
// add identifier because one or more object linked has been updated
|
|
1911
1486
|
// see test: 'get dirty data many to one update item'
|
|
@@ -1915,52 +1490,45 @@
|
|
|
1915
1490
|
delete dirtyFields[key];
|
|
1916
1491
|
}
|
|
1917
1492
|
}
|
|
1918
|
-
|
|
1919
1493
|
return dirtyFields;
|
|
1920
1494
|
}
|
|
1921
1495
|
}, {
|
|
1922
1496
|
key: "_getDirtyFields",
|
|
1923
1497
|
value: function _getDirtyFields(newSerializedModel, oldSerializedModel, classMetadata) {
|
|
1924
1498
|
var _this2 = this;
|
|
1925
|
-
|
|
1926
1499
|
var dirtyFields = {};
|
|
1927
1500
|
Object.values(classMetadata.getAttributeList()).forEach(function (attribute) {
|
|
1928
1501
|
var key = attribute.attributeName;
|
|
1929
1502
|
var newValue = newSerializedModel[key];
|
|
1930
1503
|
var oldValue = oldSerializedModel ? oldSerializedModel[key] : null;
|
|
1931
1504
|
var currentRelation = classMetadata.getRelation(attribute.serializedKey);
|
|
1932
|
-
|
|
1933
1505
|
if (newValue === undefined) {
|
|
1934
1506
|
return;
|
|
1935
|
-
}
|
|
1936
|
-
|
|
1507
|
+
}
|
|
1937
1508
|
|
|
1509
|
+
// not a relation
|
|
1938
1510
|
if (!currentRelation) {
|
|
1939
1511
|
dirtyFields = _this2._getDirtyFieldsForAttribute(dirtyFields, key, attribute, oldValue, newValue);
|
|
1940
1512
|
return;
|
|
1941
1513
|
}
|
|
1942
|
-
|
|
1943
1514
|
var relationMetadata = _this2.mapping.getClassMetadataByKey(currentRelation.targetMetadataKey);
|
|
1944
|
-
|
|
1945
1515
|
if (!relationMetadata) {
|
|
1946
1516
|
throw new TypeError("relation metadata is not set for relation ".concat(classMetadata.key, ".").concat(currentRelation.targetMetadataKey));
|
|
1947
1517
|
}
|
|
1518
|
+
var idSerializedKey = relationMetadata.getIdentifierAttribute().serializedKey;
|
|
1948
1519
|
|
|
1949
|
-
|
|
1950
|
-
|
|
1520
|
+
// MANY_TO_ONE relation
|
|
1951
1521
|
if (currentRelation.isRelationToOne()) {
|
|
1952
1522
|
dirtyFields = _this2._getDirtyFieldsForManyToOne(dirtyFields, key, oldValue, newValue, relationMetadata, idSerializedKey);
|
|
1953
1523
|
return;
|
|
1954
|
-
}
|
|
1955
|
-
|
|
1524
|
+
}
|
|
1956
1525
|
|
|
1526
|
+
// *_TO_MANY relation
|
|
1957
1527
|
dirtyFields = _this2._getDirtyFieldsForOneToMany(dirtyFields, key, idSerializedKey, relationMetadata, oldValue, newValue);
|
|
1958
1528
|
});
|
|
1959
1529
|
return dirtyFields;
|
|
1960
1530
|
}
|
|
1961
1531
|
}]);
|
|
1962
|
-
|
|
1963
|
-
return UnitOfWork;
|
|
1964
1532
|
}();
|
|
1965
1533
|
|
|
1966
1534
|
/* eslint-disable @typescript-eslint/no-unused-vars */
|
|
@@ -1968,44 +1536,44 @@
|
|
|
1968
1536
|
function Serializer() {
|
|
1969
1537
|
_classCallCheck(this, Serializer);
|
|
1970
1538
|
}
|
|
1971
|
-
|
|
1972
|
-
_createClass(Serializer, [{
|
|
1539
|
+
return _createClass(Serializer, [{
|
|
1973
1540
|
key: "normalizeItem",
|
|
1974
|
-
|
|
1541
|
+
value:
|
|
1975
1542
|
/**
|
|
1976
1543
|
* convert an entity to a plain javascript object
|
|
1977
1544
|
* @param {object} entity - The entity to convert
|
|
1978
1545
|
* @param {ClassMetadata} classMetadata - the class metadata
|
|
1979
1546
|
* @return {object} the object to serialize
|
|
1980
1547
|
*/
|
|
1981
|
-
|
|
1548
|
+
function normalizeItem(entity, classMetadata) {
|
|
1982
1549
|
return entity;
|
|
1983
1550
|
}
|
|
1551
|
+
|
|
1984
1552
|
/**
|
|
1985
1553
|
* convert a plain javascript object to string
|
|
1986
1554
|
* @param {object} object - The object to convert to convert
|
|
1987
1555
|
* @param {ClassMetadata} classMetadata - the class metadata
|
|
1988
1556
|
* @return {string} the content of the request
|
|
1989
1557
|
*/
|
|
1990
|
-
|
|
1991
1558
|
}, {
|
|
1992
1559
|
key: "encodeItem",
|
|
1993
1560
|
value: function encodeItem(object, classMetadata) {
|
|
1994
1561
|
throw new TypeError('`encodeItem` method must be implemented');
|
|
1995
1562
|
}
|
|
1563
|
+
|
|
1996
1564
|
/**
|
|
1997
1565
|
* convert an entity to string that will be sent as the request content
|
|
1998
1566
|
* @param {any} entity - The entity to convert
|
|
1999
1567
|
* @param {ClassMetadata} classMetadata - the class metadata
|
|
2000
1568
|
* @return {string} the content of the request
|
|
2001
1569
|
*/
|
|
2002
|
-
|
|
2003
1570
|
}, {
|
|
2004
1571
|
key: "serializeItem",
|
|
2005
1572
|
value: function serializeItem(object, classMetadata) {
|
|
2006
1573
|
var noralizedData = this.normalizeItem(object, classMetadata);
|
|
2007
1574
|
return this.encodeItem(noralizedData, classMetadata);
|
|
2008
1575
|
}
|
|
1576
|
+
|
|
2009
1577
|
/**
|
|
2010
1578
|
* convert a plain object to an entity
|
|
2011
1579
|
* @param {object} object - The plain javascript object
|
|
@@ -2013,12 +1581,12 @@
|
|
|
2013
1581
|
* @param {Record<string, unknown>} response - the HTTP response
|
|
2014
1582
|
* @return {object} an entity
|
|
2015
1583
|
*/
|
|
2016
|
-
|
|
2017
1584
|
}, {
|
|
2018
1585
|
key: "denormalizeItem",
|
|
2019
1586
|
value: function denormalizeItem(object, classMetadata, response) {
|
|
2020
1587
|
return object;
|
|
2021
1588
|
}
|
|
1589
|
+
|
|
2022
1590
|
/**
|
|
2023
1591
|
* convert a string containing an object to a plain javascript object
|
|
2024
1592
|
* @param {string} rawData - The string fetched from the response
|
|
@@ -2026,12 +1594,12 @@
|
|
|
2026
1594
|
* @param {Record<string, unknown>} response - the HTTP response
|
|
2027
1595
|
* @return {object} the normalized object
|
|
2028
1596
|
*/
|
|
2029
|
-
|
|
2030
1597
|
}, {
|
|
2031
1598
|
key: "decodeItem",
|
|
2032
1599
|
value: function decodeItem(rawData, classMetadata, response) {
|
|
2033
1600
|
throw new TypeError('`decodeItem` method must be implemented');
|
|
2034
1601
|
}
|
|
1602
|
+
|
|
2035
1603
|
/**
|
|
2036
1604
|
* convert a string containing an object to an entity
|
|
2037
1605
|
* @param {string} rawData - The string fetched from the response
|
|
@@ -2039,13 +1607,13 @@
|
|
|
2039
1607
|
* @param {Record<string, unknown>} response - the HTTP response
|
|
2040
1608
|
* @return {object} the entity
|
|
2041
1609
|
*/
|
|
2042
|
-
|
|
2043
1610
|
}, {
|
|
2044
1611
|
key: "deserializeItem",
|
|
2045
1612
|
value: function deserializeItem(rawData, classMetadata, response) {
|
|
2046
1613
|
var object = this.decodeItem(rawData, classMetadata, response);
|
|
2047
1614
|
return this.denormalizeItem(object, classMetadata, response);
|
|
2048
1615
|
}
|
|
1616
|
+
|
|
2049
1617
|
/**
|
|
2050
1618
|
* convert a plain object list to an entity list
|
|
2051
1619
|
* @param {Iterable<object>} objectList - The plain javascript object list (or an iterable object)
|
|
@@ -2053,12 +1621,12 @@
|
|
|
2053
1621
|
* @param {Record<string, unknown>} response - the HTTP response
|
|
2054
1622
|
* @return {Iterable<object>} a list of entities
|
|
2055
1623
|
*/
|
|
2056
|
-
|
|
2057
1624
|
}, {
|
|
2058
1625
|
key: "denormalizeList",
|
|
2059
1626
|
value: function denormalizeList(objectList, classMetadata, response) {
|
|
2060
1627
|
return objectList; // weird conversion as the declaration of list type is fuzzy
|
|
2061
1628
|
}
|
|
1629
|
+
|
|
2062
1630
|
/**
|
|
2063
1631
|
* convert a string containing a list of objects to a list of plain javascript objects
|
|
2064
1632
|
* @param {string} rawListData - The string fetched from the response
|
|
@@ -2066,12 +1634,12 @@
|
|
|
2066
1634
|
* @param {Record<string, unknown>} response - the HTTP response
|
|
2067
1635
|
* @return {Iterable<object>} a list of normalized objects
|
|
2068
1636
|
*/
|
|
2069
|
-
|
|
2070
1637
|
}, {
|
|
2071
1638
|
key: "decodeList",
|
|
2072
1639
|
value: function decodeList(rawListData, classMetadata, response) {
|
|
2073
1640
|
throw new TypeError('`deserializeList` method must be implemented');
|
|
2074
1641
|
}
|
|
1642
|
+
|
|
2075
1643
|
/**
|
|
2076
1644
|
* convert a string containing a list of objects to a list of entities
|
|
2077
1645
|
* @param {string} rawListData - The string fetched from the response
|
|
@@ -2079,7 +1647,6 @@
|
|
|
2079
1647
|
* @param {Record<string, unknown>} response - the HTTP response
|
|
2080
1648
|
* @return {Iterable<object>} a list of entities
|
|
2081
1649
|
*/
|
|
2082
|
-
|
|
2083
1650
|
}, {
|
|
2084
1651
|
key: "deserializeList",
|
|
2085
1652
|
value: function deserializeList(rawListData, classMetadata, response) {
|
|
@@ -2087,22 +1654,15 @@
|
|
|
2087
1654
|
return this.denormalizeList(objectList, classMetadata, response);
|
|
2088
1655
|
}
|
|
2089
1656
|
}]);
|
|
2090
|
-
|
|
2091
|
-
return Serializer;
|
|
2092
1657
|
}();
|
|
2093
1658
|
|
|
2094
1659
|
var JsSerializer = /*#__PURE__*/function (_Serializer) {
|
|
2095
|
-
_inherits(JsSerializer, _Serializer);
|
|
2096
|
-
|
|
2097
|
-
var _super = _createSuper(JsSerializer);
|
|
2098
|
-
|
|
2099
1660
|
function JsSerializer() {
|
|
2100
1661
|
_classCallCheck(this, JsSerializer);
|
|
2101
|
-
|
|
2102
|
-
return _super.apply(this, arguments);
|
|
1662
|
+
return _callSuper(this, JsSerializer, arguments);
|
|
2103
1663
|
}
|
|
2104
|
-
|
|
2105
|
-
_createClass(JsSerializer, [{
|
|
1664
|
+
_inherits(JsSerializer, _Serializer);
|
|
1665
|
+
return _createClass(JsSerializer, [{
|
|
2106
1666
|
key: "encodeItem",
|
|
2107
1667
|
value: function encodeItem(object, classMetadata) {
|
|
2108
1668
|
return JSON.stringify(object);
|
|
@@ -2118,66 +1678,60 @@
|
|
|
2118
1678
|
return JSON.parse(rawListData);
|
|
2119
1679
|
}
|
|
2120
1680
|
}]);
|
|
2121
|
-
|
|
2122
|
-
return JsSerializer;
|
|
2123
1681
|
}(Serializer);
|
|
2124
1682
|
|
|
2125
1683
|
function levenshteinDistance(a, b) {
|
|
2126
|
-
var matrix = [];
|
|
1684
|
+
var matrix = [];
|
|
2127
1685
|
|
|
1686
|
+
// Increment along the first column of each row
|
|
2128
1687
|
for (var i = 0; i <= b.length; i += 1) {
|
|
2129
1688
|
matrix[i] = [i];
|
|
2130
|
-
}
|
|
2131
|
-
|
|
1689
|
+
}
|
|
2132
1690
|
|
|
1691
|
+
// Increment each column in the first row
|
|
2133
1692
|
for (var j = 0; j <= a.length; j += 1) {
|
|
2134
1693
|
matrix[0][j] = j;
|
|
2135
|
-
}
|
|
2136
|
-
|
|
1694
|
+
}
|
|
2137
1695
|
|
|
1696
|
+
// Fill in the rest of the matrix
|
|
2138
1697
|
for (var _i = 1; _i <= b.length; _i += 1) {
|
|
2139
1698
|
for (var _j = 1; _j <= a.length; _j += 1) {
|
|
2140
1699
|
if (b.charAt(_i - 1) === a.charAt(_j - 1)) {
|
|
2141
1700
|
matrix[_i][_j] = matrix[_i - 1][_j - 1];
|
|
2142
1701
|
} else {
|
|
2143
|
-
matrix[_i][_j] = Math.min(matrix[_i - 1][_j - 1] + 1,
|
|
2144
|
-
|
|
1702
|
+
matrix[_i][_j] = Math.min(matrix[_i - 1][_j - 1] + 1,
|
|
1703
|
+
// substitution
|
|
1704
|
+
matrix[_i][_j - 1] + 1,
|
|
1705
|
+
// insertion
|
|
2145
1706
|
matrix[_i - 1][_j] + 1 // deletion
|
|
2146
1707
|
);
|
|
2147
1708
|
}
|
|
2148
1709
|
}
|
|
2149
1710
|
}
|
|
2150
|
-
|
|
2151
1711
|
return matrix[b.length][a.length];
|
|
2152
|
-
}
|
|
2153
|
-
|
|
2154
|
-
|
|
1712
|
+
}
|
|
2155
1713
|
function findClosestWord(word, list) {
|
|
2156
1714
|
var maxDistance = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Infinity;
|
|
2157
1715
|
var closestWord = null;
|
|
2158
|
-
var minDistance = Infinity;
|
|
2159
|
-
|
|
1716
|
+
var minDistance = Infinity;
|
|
2160
1717
|
for (var i = 0; i < list.length; i += 1) {
|
|
2161
1718
|
var candidate = list[i];
|
|
2162
1719
|
var distance = levenshteinDistance(word, candidate);
|
|
2163
|
-
|
|
2164
1720
|
if (distance < minDistance && distance <= maxDistance) {
|
|
2165
1721
|
minDistance = distance;
|
|
2166
1722
|
closestWord = candidate;
|
|
2167
1723
|
}
|
|
2168
1724
|
}
|
|
2169
|
-
|
|
2170
1725
|
return closestWord;
|
|
2171
1726
|
}
|
|
2172
1727
|
|
|
1728
|
+
// type SdkResponse = Partial<Response>;
|
|
1729
|
+
|
|
2173
1730
|
var generateId = function generateId() {
|
|
2174
1731
|
return "rest-client-sdk|".concat(Date.now(), "-").concat(Math.floor(Math.random() * (9e12 - 1)) + 1e12);
|
|
2175
1732
|
};
|
|
2176
|
-
|
|
2177
1733
|
function serializeRequest(req) {
|
|
2178
1734
|
var request = _objectSpread2({}, req); // Make a clone, useful for doing destructive things
|
|
2179
|
-
|
|
2180
|
-
|
|
2181
1735
|
return {
|
|
2182
1736
|
method: request.method,
|
|
2183
1737
|
// The Request Method, e.g. GET, POST, DELETE
|
|
@@ -2186,31 +1740,20 @@
|
|
|
2186
1740
|
headers: request.headers ? convertToRecord(request.headers) : undefined,
|
|
2187
1741
|
body: typeof request.body === 'string' ? request.body : undefined
|
|
2188
1742
|
};
|
|
2189
|
-
}
|
|
2190
|
-
|
|
2191
|
-
|
|
2192
|
-
var _history = new WeakMap();
|
|
2193
|
-
|
|
1743
|
+
}
|
|
1744
|
+
var _history = /*#__PURE__*/new WeakMap();
|
|
2194
1745
|
var Logger = /*#__PURE__*/function () {
|
|
2195
|
-
_createClass(Logger, [{
|
|
2196
|
-
key: "history",
|
|
2197
|
-
get: function get() {
|
|
2198
|
-
return _classPrivateFieldGet(this, _history);
|
|
2199
|
-
}
|
|
2200
|
-
}]);
|
|
2201
|
-
|
|
2202
1746
|
function Logger() {
|
|
2203
1747
|
_classCallCheck(this, Logger);
|
|
2204
|
-
|
|
2205
|
-
_history
|
|
2206
|
-
writable: true,
|
|
2207
|
-
value: void 0
|
|
2208
|
-
});
|
|
2209
|
-
|
|
2210
|
-
_classPrivateFieldSet(this, _history, []);
|
|
1748
|
+
_classPrivateFieldInitSpec(this, _history, void 0);
|
|
1749
|
+
_classPrivateFieldSet2(_history, this, []);
|
|
2211
1750
|
}
|
|
2212
|
-
|
|
2213
|
-
|
|
1751
|
+
return _createClass(Logger, [{
|
|
1752
|
+
key: "history",
|
|
1753
|
+
get: function get() {
|
|
1754
|
+
return _classPrivateFieldGet2(_history, this);
|
|
1755
|
+
}
|
|
1756
|
+
}, {
|
|
2214
1757
|
key: "logRequest",
|
|
2215
1758
|
value: function logRequest(params) {
|
|
2216
1759
|
var log = {
|
|
@@ -2220,15 +1763,15 @@
|
|
|
2220
1763
|
request: Date.now()
|
|
2221
1764
|
}
|
|
2222
1765
|
};
|
|
2223
|
-
|
|
2224
|
-
_classPrivateFieldGet(this, _history).push(log);
|
|
2225
|
-
|
|
1766
|
+
_classPrivateFieldGet2(_history, this).push(log);
|
|
2226
1767
|
return log.id;
|
|
2227
1768
|
}
|
|
2228
1769
|
}, {
|
|
2229
1770
|
key: "logResponse",
|
|
2230
1771
|
value: function logResponse(response, requestId) {
|
|
2231
|
-
var id = requestId || generateId();
|
|
1772
|
+
var id = requestId || generateId();
|
|
1773
|
+
|
|
1774
|
+
// console.log('clone');
|
|
2232
1775
|
// const clonedResponse = response.clone(); // THIS IS THE LINE THAT CAUSES THE PROBLEM
|
|
2233
1776
|
// console.log('after clone', clonedResponse.status);
|
|
2234
1777
|
|
|
@@ -2237,16 +1780,14 @@
|
|
|
2237
1780
|
// clonedResponse.status,
|
|
2238
1781
|
headers: Object.fromEntries(response.headers)
|
|
2239
1782
|
};
|
|
2240
|
-
|
|
2241
|
-
var foundLogIndex = _classPrivateFieldGet(this, _history).findIndex(function (log) {
|
|
1783
|
+
var foundLogIndex = _classPrivateFieldGet2(_history, this).findIndex(function (log) {
|
|
2242
1784
|
return log.id === id;
|
|
2243
1785
|
});
|
|
2244
|
-
|
|
2245
1786
|
if (foundLogIndex > -1) {
|
|
2246
|
-
|
|
2247
|
-
|
|
1787
|
+
_classPrivateFieldGet2(_history, this)[foundLogIndex].response = logContent;
|
|
1788
|
+
_classPrivateFieldGet2(_history, this)[foundLogIndex].logTimes.response = Date.now();
|
|
2248
1789
|
} else {
|
|
2249
|
-
|
|
1790
|
+
_classPrivateFieldGet2(_history, this).push({
|
|
2250
1791
|
id: id,
|
|
2251
1792
|
response: logContent,
|
|
2252
1793
|
logTimes: {
|
|
@@ -2254,82 +1795,59 @@
|
|
|
2254
1795
|
}
|
|
2255
1796
|
});
|
|
2256
1797
|
}
|
|
2257
|
-
|
|
2258
1798
|
return id;
|
|
2259
1799
|
}
|
|
2260
1800
|
}]);
|
|
2261
|
-
|
|
2262
|
-
return Logger;
|
|
2263
1801
|
}();
|
|
2264
1802
|
|
|
2265
|
-
|
|
1803
|
+
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
2266
1804
|
|
|
1805
|
+
// export type SdkMetadata = Record<string, [any, Iterable<any>, undefined | any]>;
|
|
1806
|
+
var _repositoryList = /*#__PURE__*/new WeakMap();
|
|
2267
1807
|
var RestClientSdk = /*#__PURE__*/function () {
|
|
2268
1808
|
function RestClientSdk(tokenStorage, config, mapping) {
|
|
2269
1809
|
var serializer = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : new JsSerializer();
|
|
2270
|
-
|
|
2271
1810
|
_classCallCheck(this, RestClientSdk);
|
|
2272
|
-
|
|
2273
1811
|
_defineProperty(this, "config", void 0);
|
|
2274
|
-
|
|
2275
1812
|
_defineProperty(this, "tokenStorage", void 0);
|
|
2276
|
-
|
|
2277
1813
|
_defineProperty(this, "serializer", void 0);
|
|
2278
|
-
|
|
2279
1814
|
_defineProperty(this, "mapping", void 0);
|
|
2280
|
-
|
|
2281
1815
|
_defineProperty(this, "unitOfWork", void 0);
|
|
2282
|
-
|
|
2283
|
-
_repositoryList.set(this, {
|
|
2284
|
-
writable: true,
|
|
2285
|
-
value: void 0
|
|
2286
|
-
});
|
|
2287
|
-
|
|
1816
|
+
_classPrivateFieldInitSpec(this, _repositoryList, void 0);
|
|
2288
1817
|
_defineProperty(this, "logger", void 0);
|
|
2289
|
-
|
|
2290
1818
|
this.checkConfigValidity(config);
|
|
2291
|
-
|
|
2292
1819
|
if (!(mapping instanceof Mapping)) {
|
|
2293
1820
|
throw new TypeError('mapping should be an instance of `Mapping`');
|
|
2294
1821
|
}
|
|
2295
|
-
|
|
2296
1822
|
this.config = this._mergeWithBaseConfig(config);
|
|
2297
1823
|
this.tokenStorage = tokenStorage;
|
|
2298
1824
|
this.serializer = serializer;
|
|
2299
1825
|
this.mapping = mapping;
|
|
2300
1826
|
this.unitOfWork = new UnitOfWork(this.mapping, this.config.unitOfWorkEnabled);
|
|
2301
|
-
|
|
2302
1827
|
if (config.loggerEnabled) {
|
|
2303
1828
|
this.logger = new Logger();
|
|
2304
1829
|
}
|
|
2305
|
-
|
|
2306
|
-
_classPrivateFieldSet(this, _repositoryList, {});
|
|
1830
|
+
_classPrivateFieldSet2(_repositoryList, this, {});
|
|
2307
1831
|
}
|
|
1832
|
+
|
|
2308
1833
|
/**
|
|
2309
1834
|
* get a repository by it's metadata "key" attribute
|
|
2310
1835
|
*
|
|
2311
1836
|
* @param {string} key the repository "key" (the first argument of `new ClassMetadata`)
|
|
2312
1837
|
*/
|
|
2313
|
-
|
|
2314
|
-
|
|
2315
|
-
_createClass(RestClientSdk, [{
|
|
1838
|
+
return _createClass(RestClientSdk, [{
|
|
2316
1839
|
key: "getRepository",
|
|
2317
1840
|
value: function getRepository(key) {
|
|
2318
|
-
if (!
|
|
1841
|
+
if (!_classPrivateFieldGet2(_repositoryList, this)[key]) {
|
|
2319
1842
|
var metadata = this.mapping.getClassMetadataByKey(key);
|
|
2320
|
-
|
|
2321
1843
|
if (!metadata) {
|
|
2322
1844
|
var closeKey = findClosestWord(key, this.mapping.getMappingKeys(), 5);
|
|
2323
1845
|
var suggestions = closeKey ? " Did you mean \"".concat(closeKey, "\"?") : '';
|
|
2324
1846
|
throw new Error("Unable to get metadata for repository \"".concat(key, "\".").concat(suggestions));
|
|
2325
|
-
}
|
|
2326
|
-
|
|
2327
|
-
|
|
2328
|
-
|
|
2329
|
-
} // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
|
2330
|
-
|
|
2331
|
-
|
|
2332
|
-
return _classPrivateFieldGet(this, _repositoryList)[key];
|
|
1847
|
+
}
|
|
1848
|
+
_classPrivateFieldGet2(_repositoryList, this)[key] = generateRepository(this, metadata, this.config.unitOfWorkEnabled);
|
|
1849
|
+
}
|
|
1850
|
+
return _classPrivateFieldGet2(_repositoryList, this)[key];
|
|
2333
1851
|
}
|
|
2334
1852
|
}, {
|
|
2335
1853
|
key: "_mergeWithBaseConfig",
|
|
@@ -2347,49 +1865,37 @@
|
|
|
2347
1865
|
}
|
|
2348
1866
|
}
|
|
2349
1867
|
}]);
|
|
2350
|
-
|
|
2351
|
-
return RestClientSdk;
|
|
2352
1868
|
}();
|
|
2353
1869
|
|
|
2354
1870
|
var AbstractTokenGenerator = /*#__PURE__*/function () {
|
|
2355
1871
|
function AbstractTokenGenerator(tokenGeneratorConfig, logger) {
|
|
2356
1872
|
_classCallCheck(this, AbstractTokenGenerator);
|
|
2357
|
-
|
|
2358
1873
|
_defineProperty(this, "tokenGeneratorConfig", void 0);
|
|
2359
|
-
|
|
2360
1874
|
_defineProperty(this, "logger", void 0);
|
|
2361
|
-
|
|
2362
1875
|
if (logger) {
|
|
2363
1876
|
this.logger = logger;
|
|
2364
1877
|
}
|
|
2365
|
-
|
|
2366
1878
|
this.tokenGeneratorConfig = tokenGeneratorConfig;
|
|
2367
|
-
|
|
2368
1879
|
if (typeof this.checkTokenGeneratorConfig === 'function') {
|
|
2369
1880
|
this.checkTokenGeneratorConfig(this.tokenGeneratorConfig);
|
|
2370
1881
|
}
|
|
2371
1882
|
}
|
|
2372
|
-
|
|
2373
|
-
_createClass(AbstractTokenGenerator, [{
|
|
1883
|
+
return _createClass(AbstractTokenGenerator, [{
|
|
2374
1884
|
key: "_manageOauthError",
|
|
2375
|
-
|
|
2376
|
-
|
|
2377
|
-
value: function _manageOauthError(response) {
|
|
1885
|
+
value: /** @deprecated */
|
|
1886
|
+
function _manageOauthError(response) {
|
|
2378
1887
|
return response.clone().json().then(function (body) {
|
|
2379
1888
|
if (body.error === 'invalid_grant') {
|
|
2380
1889
|
throw new InvalidGrantError(body.error, getHttpErrorFromResponse(response));
|
|
2381
1890
|
}
|
|
2382
|
-
|
|
2383
1891
|
if (body.error === 'invalid_scope') {
|
|
2384
1892
|
throw new InvalidScopeError(body.error, getHttpErrorFromResponse(response));
|
|
2385
1893
|
}
|
|
2386
|
-
|
|
2387
1894
|
throw new OauthError(body.error, getHttpErrorFromResponse(response));
|
|
2388
1895
|
})["catch"](function (err) {
|
|
2389
1896
|
if (!(err instanceof OauthError)) {
|
|
2390
1897
|
throw new OauthError(err.type, getHttpErrorFromResponse(response));
|
|
2391
1898
|
}
|
|
2392
|
-
|
|
2393
1899
|
throw err;
|
|
2394
1900
|
});
|
|
2395
1901
|
}
|
|
@@ -2397,16 +1903,12 @@
|
|
|
2397
1903
|
key: "generateUrlFromConfig",
|
|
2398
1904
|
value: function generateUrlFromConfig(config) {
|
|
2399
1905
|
var uri = new URI("".concat(config.scheme, "://").concat(config.path));
|
|
2400
|
-
|
|
2401
1906
|
if (config.port) {
|
|
2402
1907
|
uri.port(config.port);
|
|
2403
1908
|
}
|
|
2404
|
-
|
|
2405
1909
|
return uri.toString();
|
|
2406
1910
|
}
|
|
2407
1911
|
}]);
|
|
2408
|
-
|
|
2409
|
-
return AbstractTokenGenerator;
|
|
2410
1912
|
}();
|
|
2411
1913
|
|
|
2412
1914
|
/**
|
|
@@ -2415,25 +1917,19 @@
|
|
|
2415
1917
|
* @See {@link https://oauth2.thephpleague.com/authorization-server/auth-code-grant/|the great article of the PHP League} about authorization code flow.
|
|
2416
1918
|
*/
|
|
2417
1919
|
var AuthorizationCodeFlowTokenGenerator = /*#__PURE__*/function (_AbstractTokenGenerat) {
|
|
2418
|
-
_inherits(AuthorizationCodeFlowTokenGenerator, _AbstractTokenGenerat);
|
|
2419
|
-
|
|
2420
|
-
var _super = _createSuper(AuthorizationCodeFlowTokenGenerator);
|
|
2421
|
-
|
|
2422
1920
|
function AuthorizationCodeFlowTokenGenerator() {
|
|
2423
1921
|
_classCallCheck(this, AuthorizationCodeFlowTokenGenerator);
|
|
2424
|
-
|
|
2425
|
-
return _super.apply(this, arguments);
|
|
1922
|
+
return _callSuper(this, AuthorizationCodeFlowTokenGenerator, arguments);
|
|
2426
1923
|
}
|
|
2427
|
-
|
|
2428
|
-
_createClass(AuthorizationCodeFlowTokenGenerator, [{
|
|
1924
|
+
_inherits(AuthorizationCodeFlowTokenGenerator, _AbstractTokenGenerat);
|
|
1925
|
+
return _createClass(AuthorizationCodeFlowTokenGenerator, [{
|
|
2429
1926
|
key: "generateToken",
|
|
2430
|
-
|
|
1927
|
+
value:
|
|
2431
1928
|
/**
|
|
2432
1929
|
* This function needs no generate an access token
|
|
2433
1930
|
*/
|
|
2434
|
-
|
|
1931
|
+
function generateToken(parameters) {
|
|
2435
1932
|
this._checkGenerateParameters(parameters);
|
|
2436
|
-
|
|
2437
1933
|
var url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
|
|
2438
1934
|
var params = {
|
|
2439
1935
|
method: 'POST',
|
|
@@ -2449,31 +1945,27 @@
|
|
|
2449
1945
|
code: parameters.code
|
|
2450
1946
|
}).toString()
|
|
2451
1947
|
};
|
|
2452
|
-
|
|
2453
1948
|
if (this.logger) {
|
|
2454
1949
|
this.logger.logRequest(_objectSpread2({
|
|
2455
1950
|
url: url
|
|
2456
1951
|
}, params));
|
|
2457
1952
|
}
|
|
2458
|
-
|
|
2459
1953
|
return fetch(url, params);
|
|
2460
1954
|
}
|
|
1955
|
+
|
|
2461
1956
|
/**
|
|
2462
1957
|
* This function needs to refresh the current possibly expired access token
|
|
2463
1958
|
* and return a Promise that will be resolved with a fresh access token
|
|
2464
1959
|
*/
|
|
2465
|
-
|
|
2466
1960
|
}, {
|
|
2467
1961
|
key: "refreshToken",
|
|
2468
1962
|
value: function refreshToken(oldAccessToken) {
|
|
2469
1963
|
if (!oldAccessToken) {
|
|
2470
1964
|
throw new Error('refresh_token is not set. Did you called `generateToken` before ?');
|
|
2471
1965
|
}
|
|
2472
|
-
|
|
2473
|
-
if (!(oldAccessToken === null || oldAccessToken === void 0 ? void 0 : oldAccessToken.refresh_token)) {
|
|
1966
|
+
if (!(oldAccessToken !== null && oldAccessToken !== void 0 && oldAccessToken.refresh_token)) {
|
|
2474
1967
|
throw new Error('Unable to refreshToken as there are no refresh_token');
|
|
2475
1968
|
}
|
|
2476
|
-
|
|
2477
1969
|
var url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
|
|
2478
1970
|
var params = {
|
|
2479
1971
|
method: 'POST',
|
|
@@ -2487,13 +1979,11 @@
|
|
|
2487
1979
|
refresh_token: oldAccessToken.refresh_token
|
|
2488
1980
|
}).toString()
|
|
2489
1981
|
};
|
|
2490
|
-
|
|
2491
1982
|
if (this.logger) {
|
|
2492
1983
|
this.logger.logRequest(_objectSpread2({
|
|
2493
1984
|
url: url
|
|
2494
1985
|
}, params));
|
|
2495
1986
|
}
|
|
2496
|
-
|
|
2497
1987
|
return fetch(url, params);
|
|
2498
1988
|
}
|
|
2499
1989
|
}, {
|
|
@@ -2502,15 +1992,12 @@
|
|
|
2502
1992
|
if (!config || Object.keys(config).length === 0) {
|
|
2503
1993
|
throw new RangeError('TokenGenerator config must be set');
|
|
2504
1994
|
}
|
|
2505
|
-
|
|
2506
1995
|
if (!(config.path && config.scheme)) {
|
|
2507
1996
|
throw new RangeError('TokenGenerator config is not valid, it should contain a "path", a "scheme" parameter');
|
|
2508
1997
|
}
|
|
2509
|
-
|
|
2510
1998
|
if (!(config.clientId && config.clientSecret)) {
|
|
2511
1999
|
throw new RangeError('TokenGenerator config is not valid, it should contain a "clientId", a "clientSecret" parameter');
|
|
2512
2000
|
}
|
|
2513
|
-
|
|
2514
2001
|
if (!config.redirectUri) {
|
|
2515
2002
|
throw new RangeError('TokenGenerator config is not valid, it should contain a "redirectUri" parameter');
|
|
2516
2003
|
}
|
|
@@ -2521,43 +2008,36 @@
|
|
|
2521
2008
|
if (!(parameters && Object.keys(parameters).length > 0)) {
|
|
2522
2009
|
throw new RangeError('parameters must be set');
|
|
2523
2010
|
}
|
|
2524
|
-
|
|
2525
2011
|
if (!parameters.code) {
|
|
2526
2012
|
throw new RangeError('"code" must be passed as parameter');
|
|
2527
2013
|
}
|
|
2528
2014
|
}
|
|
2529
2015
|
}]);
|
|
2530
|
-
|
|
2531
|
-
return AuthorizationCodeFlowTokenGenerator;
|
|
2532
2016
|
}(AbstractTokenGenerator);
|
|
2533
2017
|
|
|
2534
|
-
/* eslint-disable import/prefer-default-export */
|
|
2535
2018
|
// memoize promise returning function so that it returns
|
|
2536
2019
|
// the same promise if called again before resolve / reject
|
|
2020
|
+
|
|
2537
2021
|
function memoizePromise(callback) {
|
|
2538
2022
|
var cache = {};
|
|
2539
|
-
|
|
2540
2023
|
function memoized() {
|
|
2541
2024
|
for (var _len = arguments.length, parameters = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
2542
2025
|
parameters[_key] = arguments[_key];
|
|
2543
2026
|
}
|
|
2544
|
-
|
|
2545
2027
|
var cacheKey = JSON.stringify(parameters);
|
|
2546
2028
|
var cacheValue = cache[cacheKey];
|
|
2547
|
-
|
|
2548
2029
|
if (cacheValue) {
|
|
2549
2030
|
return cacheValue;
|
|
2550
|
-
}
|
|
2551
|
-
|
|
2031
|
+
}
|
|
2552
2032
|
|
|
2033
|
+
// Get and add the value to the cache
|
|
2553
2034
|
var value = callback.apply(this, parameters);
|
|
2554
2035
|
cache[cacheKey] = value;
|
|
2555
|
-
|
|
2556
2036
|
if (!value || typeof value.then !== 'function') {
|
|
2557
2037
|
throw new Error('Memoization Error, Async function returned non-promise value');
|
|
2558
|
-
}
|
|
2559
|
-
|
|
2038
|
+
}
|
|
2560
2039
|
|
|
2040
|
+
// Delete the value regardless of whether it resolves or rejects
|
|
2561
2041
|
return value.then(function (internalValue) {
|
|
2562
2042
|
cache[cacheKey] = false;
|
|
2563
2043
|
return internalValue;
|
|
@@ -2566,31 +2046,23 @@
|
|
|
2566
2046
|
throw err;
|
|
2567
2047
|
});
|
|
2568
2048
|
}
|
|
2569
|
-
|
|
2570
2049
|
memoized.cache = cache;
|
|
2571
2050
|
return memoized;
|
|
2572
2051
|
}
|
|
2573
2052
|
|
|
2574
|
-
var ERROR_CONFIG_EMPTY = 'TokenGenerator config must be set';
|
|
2575
|
-
var ERROR_CONFIG_PATH_SCHEME = 'TokenGenerator config is not valid, it should contain a "path", a "scheme" parameter';
|
|
2576
|
-
var ERROR_CONFIG_CLIENT_INFORMATIONS = 'TokenGenerator config is not valid, it should contain a "clientId", a "clientSecret" parameter';
|
|
2577
|
-
|
|
2053
|
+
var ERROR_CONFIG_EMPTY$1 = 'TokenGenerator config must be set';
|
|
2054
|
+
var ERROR_CONFIG_PATH_SCHEME$1 = 'TokenGenerator config is not valid, it should contain a "path", a "scheme" parameter';
|
|
2055
|
+
var ERROR_CONFIG_CLIENT_INFORMATIONS$1 = 'TokenGenerator config is not valid, it should contain a "clientId", a "clientSecret" parameter';
|
|
2578
2056
|
var ClientCredentialsGenerator = /*#__PURE__*/function (_AbstractTokenGenerat) {
|
|
2579
|
-
_inherits(ClientCredentialsGenerator, _AbstractTokenGenerat);
|
|
2580
|
-
|
|
2581
|
-
var _super = _createSuper(ClientCredentialsGenerator);
|
|
2582
|
-
|
|
2583
2057
|
function ClientCredentialsGenerator(tokenGeneratorConfig) {
|
|
2584
2058
|
var _this;
|
|
2585
|
-
|
|
2586
2059
|
_classCallCheck(this, ClientCredentialsGenerator);
|
|
2587
|
-
|
|
2588
|
-
_this = _super.call(this, tokenGeneratorConfig);
|
|
2060
|
+
_this = _callSuper(this, ClientCredentialsGenerator, [tokenGeneratorConfig]);
|
|
2589
2061
|
_this.generateToken = memoizePromise(_this.generateToken);
|
|
2590
2062
|
return _this;
|
|
2591
2063
|
}
|
|
2592
|
-
|
|
2593
|
-
_createClass(ClientCredentialsGenerator, [{
|
|
2064
|
+
_inherits(ClientCredentialsGenerator, _AbstractTokenGenerat);
|
|
2065
|
+
return _createClass(ClientCredentialsGenerator, [{
|
|
2594
2066
|
key: "generateToken",
|
|
2595
2067
|
value: function generateToken() {
|
|
2596
2068
|
var baseParameters = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
@@ -2599,13 +2071,11 @@
|
|
|
2599
2071
|
client_id: this.tokenGeneratorConfig.clientId,
|
|
2600
2072
|
client_secret: this.tokenGeneratorConfig.clientSecret
|
|
2601
2073
|
});
|
|
2602
|
-
|
|
2603
2074
|
if (baseParameters.scope) {
|
|
2604
2075
|
body.append('scope', baseParameters.scope);
|
|
2605
2076
|
} else if (this.tokenGeneratorConfig.scope) {
|
|
2606
2077
|
body.append('scope', this.tokenGeneratorConfig.scope);
|
|
2607
2078
|
}
|
|
2608
|
-
|
|
2609
2079
|
var params = {
|
|
2610
2080
|
method: 'POST',
|
|
2611
2081
|
headers: {
|
|
@@ -2614,18 +2084,17 @@
|
|
|
2614
2084
|
body: body.toString()
|
|
2615
2085
|
};
|
|
2616
2086
|
var url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
|
|
2617
|
-
|
|
2618
2087
|
if (this.logger) {
|
|
2619
2088
|
this.logger.logRequest(_objectSpread2({
|
|
2620
2089
|
url: url
|
|
2621
2090
|
}, params));
|
|
2622
2091
|
}
|
|
2623
|
-
|
|
2624
2092
|
return fetch(url, params);
|
|
2625
2093
|
}
|
|
2626
2094
|
}, {
|
|
2627
2095
|
key: "refreshToken",
|
|
2628
|
-
value: function refreshToken(
|
|
2096
|
+
value: function refreshToken(
|
|
2097
|
+
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
2629
2098
|
accessToken) {
|
|
2630
2099
|
return this.generateToken({});
|
|
2631
2100
|
}
|
|
@@ -2633,44 +2102,33 @@
|
|
|
2633
2102
|
key: "checkTokenGeneratorConfig",
|
|
2634
2103
|
value: function checkTokenGeneratorConfig(config) {
|
|
2635
2104
|
if (!config || Object.keys(config).length === 0) {
|
|
2636
|
-
throw new RangeError(ERROR_CONFIG_EMPTY);
|
|
2105
|
+
throw new RangeError(ERROR_CONFIG_EMPTY$1);
|
|
2637
2106
|
}
|
|
2638
|
-
|
|
2639
2107
|
if (!(config.path && config.scheme)) {
|
|
2640
|
-
throw new RangeError(ERROR_CONFIG_PATH_SCHEME);
|
|
2108
|
+
throw new RangeError(ERROR_CONFIG_PATH_SCHEME$1);
|
|
2641
2109
|
}
|
|
2642
|
-
|
|
2643
2110
|
if (!(config.clientId && config.clientSecret)) {
|
|
2644
|
-
throw new RangeError(ERROR_CONFIG_CLIENT_INFORMATIONS);
|
|
2111
|
+
throw new RangeError(ERROR_CONFIG_CLIENT_INFORMATIONS$1);
|
|
2645
2112
|
}
|
|
2646
2113
|
}
|
|
2647
2114
|
}]);
|
|
2648
|
-
|
|
2649
|
-
return ClientCredentialsGenerator;
|
|
2650
2115
|
}(AbstractTokenGenerator);
|
|
2651
2116
|
|
|
2652
|
-
var ERROR_CONFIG_EMPTY
|
|
2653
|
-
var ERROR_CONFIG_PATH_SCHEME
|
|
2654
|
-
var ERROR_CONFIG_CLIENT_INFORMATIONS
|
|
2117
|
+
var ERROR_CONFIG_EMPTY = 'TokenGenerator config must be set';
|
|
2118
|
+
var ERROR_CONFIG_PATH_SCHEME = 'TokenGenerator config is not valid, it should contain a "path", a "scheme" parameter';
|
|
2119
|
+
var ERROR_CONFIG_CLIENT_INFORMATIONS = 'TokenGenerator config is not valid, it should contain a "clientId", a "clientSecret" parameter';
|
|
2655
2120
|
var ERROR_TOKEN_EMPTY = 'parameters must be set';
|
|
2656
2121
|
var ERROR_TOKEN_USERNAME_PASSWORD = 'username and password must be passed as parameters';
|
|
2657
|
-
|
|
2658
2122
|
var PasswordGenerator = /*#__PURE__*/function (_AbstractTokenGenerat) {
|
|
2659
|
-
_inherits(PasswordGenerator, _AbstractTokenGenerat);
|
|
2660
|
-
|
|
2661
|
-
var _super = _createSuper(PasswordGenerator);
|
|
2662
|
-
|
|
2663
2123
|
function PasswordGenerator() {
|
|
2664
2124
|
_classCallCheck(this, PasswordGenerator);
|
|
2665
|
-
|
|
2666
|
-
return _super.apply(this, arguments);
|
|
2125
|
+
return _callSuper(this, PasswordGenerator, arguments);
|
|
2667
2126
|
}
|
|
2668
|
-
|
|
2669
|
-
_createClass(PasswordGenerator, [{
|
|
2127
|
+
_inherits(PasswordGenerator, _AbstractTokenGenerat);
|
|
2128
|
+
return _createClass(PasswordGenerator, [{
|
|
2670
2129
|
key: "generateToken",
|
|
2671
2130
|
value: function generateToken(baseParameters) {
|
|
2672
2131
|
this._checkGenerateParameters(baseParameters);
|
|
2673
|
-
|
|
2674
2132
|
var body = new URLSearchParams({
|
|
2675
2133
|
grant_type: 'password',
|
|
2676
2134
|
username: baseParameters.username,
|
|
@@ -2678,13 +2136,11 @@
|
|
|
2678
2136
|
client_id: this.tokenGeneratorConfig.clientId,
|
|
2679
2137
|
client_secret: this.tokenGeneratorConfig.clientSecret
|
|
2680
2138
|
});
|
|
2681
|
-
|
|
2682
2139
|
if (baseParameters.scope) {
|
|
2683
2140
|
body.append('scope', baseParameters.scope);
|
|
2684
2141
|
} else if (this.tokenGeneratorConfig.scope) {
|
|
2685
2142
|
body.append('scope', this.tokenGeneratorConfig.scope);
|
|
2686
2143
|
}
|
|
2687
|
-
|
|
2688
2144
|
var url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
|
|
2689
2145
|
var params = {
|
|
2690
2146
|
method: 'POST',
|
|
@@ -2693,35 +2149,29 @@
|
|
|
2693
2149
|
},
|
|
2694
2150
|
body: body.toString()
|
|
2695
2151
|
};
|
|
2696
|
-
|
|
2697
2152
|
if (this.logger) {
|
|
2698
2153
|
this.logger.logRequest(_objectSpread2({
|
|
2699
2154
|
url: url
|
|
2700
2155
|
}, params));
|
|
2701
2156
|
}
|
|
2702
|
-
|
|
2703
2157
|
return fetch(url, params);
|
|
2704
2158
|
}
|
|
2705
2159
|
}, {
|
|
2706
2160
|
key: "refreshToken",
|
|
2707
2161
|
value: function refreshToken(accessToken) {
|
|
2708
2162
|
var refreshToken = accessToken === null || accessToken === void 0 ? void 0 : accessToken.refresh_token;
|
|
2709
|
-
|
|
2710
2163
|
if (!refreshToken) {
|
|
2711
2164
|
throw new Error('refresh_token is not set. Did you called `generateToken` before ?');
|
|
2712
2165
|
}
|
|
2713
|
-
|
|
2714
2166
|
var body = new URLSearchParams({
|
|
2715
2167
|
grant_type: 'refresh_token',
|
|
2716
2168
|
client_id: this.tokenGeneratorConfig.clientId,
|
|
2717
2169
|
client_secret: this.tokenGeneratorConfig.clientSecret,
|
|
2718
2170
|
refresh_token: refreshToken
|
|
2719
2171
|
});
|
|
2720
|
-
|
|
2721
2172
|
if (this.tokenGeneratorConfig.scope) {
|
|
2722
2173
|
body.append('scope', this.tokenGeneratorConfig.scope);
|
|
2723
2174
|
}
|
|
2724
|
-
|
|
2725
2175
|
var url = this.generateUrlFromConfig(this.tokenGeneratorConfig);
|
|
2726
2176
|
var params = {
|
|
2727
2177
|
method: 'POST',
|
|
@@ -2730,28 +2180,24 @@
|
|
|
2730
2180
|
},
|
|
2731
2181
|
body: body.toString()
|
|
2732
2182
|
};
|
|
2733
|
-
|
|
2734
2183
|
if (this.logger) {
|
|
2735
2184
|
this.logger.logRequest(_objectSpread2({
|
|
2736
2185
|
url: url
|
|
2737
2186
|
}, params));
|
|
2738
2187
|
}
|
|
2739
|
-
|
|
2740
2188
|
return fetch(url, params);
|
|
2741
2189
|
}
|
|
2742
2190
|
}, {
|
|
2743
2191
|
key: "checkTokenGeneratorConfig",
|
|
2744
2192
|
value: function checkTokenGeneratorConfig(config) {
|
|
2745
2193
|
if (!config || Object.keys(config).length === 0) {
|
|
2746
|
-
throw new RangeError(ERROR_CONFIG_EMPTY
|
|
2194
|
+
throw new RangeError(ERROR_CONFIG_EMPTY);
|
|
2747
2195
|
}
|
|
2748
|
-
|
|
2749
2196
|
if (!(config.path && config.scheme)) {
|
|
2750
|
-
throw new RangeError(ERROR_CONFIG_PATH_SCHEME
|
|
2197
|
+
throw new RangeError(ERROR_CONFIG_PATH_SCHEME);
|
|
2751
2198
|
}
|
|
2752
|
-
|
|
2753
2199
|
if (!(config.clientId && config.clientSecret)) {
|
|
2754
|
-
throw new RangeError(ERROR_CONFIG_CLIENT_INFORMATIONS
|
|
2200
|
+
throw new RangeError(ERROR_CONFIG_CLIENT_INFORMATIONS);
|
|
2755
2201
|
}
|
|
2756
2202
|
}
|
|
2757
2203
|
}, {
|
|
@@ -2760,22 +2206,15 @@
|
|
|
2760
2206
|
if (!(parameters && Object.keys(parameters).length > 0)) {
|
|
2761
2207
|
throw new RangeError(ERROR_TOKEN_EMPTY);
|
|
2762
2208
|
}
|
|
2763
|
-
|
|
2764
2209
|
if (!(parameters.username && parameters.password)) {
|
|
2765
2210
|
throw new RangeError(ERROR_TOKEN_USERNAME_PASSWORD);
|
|
2766
2211
|
}
|
|
2767
2212
|
}
|
|
2768
2213
|
}]);
|
|
2769
|
-
|
|
2770
|
-
return PasswordGenerator;
|
|
2771
2214
|
}(AbstractTokenGenerator);
|
|
2772
2215
|
|
|
2773
|
-
var _token = new WeakMap();
|
|
2774
|
-
|
|
2775
|
-
var _refreshTokenFunc = new WeakMap();
|
|
2776
|
-
|
|
2777
|
-
/* eslint-disable camelcase */
|
|
2778
|
-
|
|
2216
|
+
var _token = /*#__PURE__*/new WeakMap();
|
|
2217
|
+
var _refreshTokenFunc = /*#__PURE__*/new WeakMap();
|
|
2779
2218
|
/**
|
|
2780
2219
|
* @deprecated ProvidedTokenGenerator is not an Oauth valid generator.
|
|
2781
2220
|
* You should use one of the official generator or implement your own custom generator.
|
|
@@ -2783,38 +2222,28 @@
|
|
|
2783
2222
|
var ProvidedTokenGenerator = /*#__PURE__*/function () {
|
|
2784
2223
|
function ProvidedTokenGenerator(token) {
|
|
2785
2224
|
var refreshTokenFunc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
|
|
2786
|
-
|
|
2787
2225
|
_classCallCheck(this, ProvidedTokenGenerator);
|
|
2788
|
-
|
|
2789
|
-
|
|
2790
|
-
|
|
2791
|
-
|
|
2792
|
-
});
|
|
2793
|
-
|
|
2794
|
-
_refreshTokenFunc.set(this, {
|
|
2795
|
-
writable: true,
|
|
2796
|
-
value: void 0
|
|
2797
|
-
});
|
|
2798
|
-
|
|
2799
|
-
_classPrivateFieldSet(this, _token, token);
|
|
2800
|
-
|
|
2801
|
-
_classPrivateFieldSet(this, _refreshTokenFunc, refreshTokenFunc);
|
|
2226
|
+
_classPrivateFieldInitSpec(this, _token, void 0);
|
|
2227
|
+
_classPrivateFieldInitSpec(this, _refreshTokenFunc, void 0);
|
|
2228
|
+
_classPrivateFieldSet2(_token, this, token);
|
|
2229
|
+
_classPrivateFieldSet2(_refreshTokenFunc, this, refreshTokenFunc);
|
|
2802
2230
|
}
|
|
2803
|
-
|
|
2804
|
-
|
|
2231
|
+
return _createClass(ProvidedTokenGenerator, [{
|
|
2232
|
+
key: "token",
|
|
2233
|
+
set: function set(token) {
|
|
2234
|
+
_classPrivateFieldSet2(_token, this, token);
|
|
2235
|
+
}
|
|
2236
|
+
}, {
|
|
2805
2237
|
key: "generateToken",
|
|
2806
|
-
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
2807
2238
|
value: function generateToken() {
|
|
2808
|
-
return Promise.resolve(
|
|
2809
|
-
}
|
|
2810
|
-
|
|
2239
|
+
return Promise.resolve(_classPrivateFieldGet2(_token, this));
|
|
2240
|
+
}
|
|
2811
2241
|
}, {
|
|
2812
2242
|
key: "refreshToken",
|
|
2813
2243
|
value: function refreshToken(accessToken) {
|
|
2814
|
-
if (typeof
|
|
2815
|
-
return
|
|
2244
|
+
if (typeof _classPrivateFieldGet2(_refreshTokenFunc, this) === 'function') {
|
|
2245
|
+
return _classPrivateFieldGet2(_refreshTokenFunc, this).call(this, accessToken);
|
|
2816
2246
|
}
|
|
2817
|
-
|
|
2818
2247
|
return this.generateToken();
|
|
2819
2248
|
}
|
|
2820
2249
|
}, {
|
|
@@ -2822,100 +2251,60 @@
|
|
|
2822
2251
|
value: function autoGenerateToken() {
|
|
2823
2252
|
return this.generateToken();
|
|
2824
2253
|
}
|
|
2825
|
-
}, {
|
|
2826
|
-
key: "token",
|
|
2827
|
-
set: function set(token) {
|
|
2828
|
-
_classPrivateFieldSet(this, _token, token);
|
|
2829
|
-
}
|
|
2830
2254
|
}]);
|
|
2831
|
-
|
|
2832
|
-
return ProvidedTokenGenerator;
|
|
2833
2255
|
}();
|
|
2834
2256
|
|
|
2835
2257
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
2836
2258
|
function isResponse(response) {
|
|
2837
2259
|
return typeof (response === null || response === void 0 ? void 0 : response.json) === 'function';
|
|
2838
2260
|
}
|
|
2839
|
-
|
|
2840
2261
|
function manageOauthError(body, response) {
|
|
2841
2262
|
var error;
|
|
2842
|
-
|
|
2843
2263
|
if (response) {
|
|
2844
2264
|
error = getHttpErrorFromResponse(response);
|
|
2845
2265
|
}
|
|
2846
|
-
|
|
2847
2266
|
if (body.error === 'invalid_grant') {
|
|
2848
2267
|
throw new InvalidGrantError(body.error, error);
|
|
2849
2268
|
}
|
|
2850
|
-
|
|
2851
2269
|
if (body.error === 'invalid_scope') {
|
|
2852
2270
|
throw new InvalidScopeError(body.error, error);
|
|
2853
2271
|
}
|
|
2854
|
-
|
|
2855
2272
|
throw new OauthError(body.error, error);
|
|
2856
2273
|
}
|
|
2857
|
-
|
|
2858
|
-
var
|
|
2859
|
-
|
|
2860
|
-
var
|
|
2861
|
-
|
|
2862
|
-
var _asyncStorage = new WeakMap();
|
|
2863
|
-
|
|
2864
|
-
var _logger = new WeakMap();
|
|
2865
|
-
|
|
2274
|
+
var _tokenGenerator = /*#__PURE__*/new WeakMap();
|
|
2275
|
+
var _hasATokenBeenGenerated = /*#__PURE__*/new WeakMap();
|
|
2276
|
+
var _asyncStorage = /*#__PURE__*/new WeakMap();
|
|
2277
|
+
var _logger = /*#__PURE__*/new WeakMap();
|
|
2866
2278
|
var TokenStorage = /*#__PURE__*/function () {
|
|
2867
2279
|
function TokenStorage(tokenGenerator, asyncStorage) {
|
|
2868
2280
|
var accessTokenKey = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'rest_client_sdk.api.access_token';
|
|
2869
2281
|
var logger = arguments.length > 3 ? arguments[3] : undefined;
|
|
2870
|
-
|
|
2871
2282
|
_classCallCheck(this, TokenStorage);
|
|
2872
|
-
|
|
2873
|
-
|
|
2874
|
-
writable: true,
|
|
2875
|
-
value: void 0
|
|
2876
|
-
});
|
|
2877
|
-
|
|
2878
|
-
_hasATokenBeenGenerated.set(this, {
|
|
2879
|
-
writable: true,
|
|
2880
|
-
value: void 0
|
|
2881
|
-
});
|
|
2882
|
-
|
|
2283
|
+
_classPrivateFieldInitSpec(this, _tokenGenerator, void 0);
|
|
2284
|
+
_classPrivateFieldInitSpec(this, _hasATokenBeenGenerated, void 0);
|
|
2883
2285
|
_defineProperty(this, "accessTokenKey", void 0);
|
|
2884
|
-
|
|
2885
|
-
|
|
2886
|
-
writable: true,
|
|
2887
|
-
value: void 0
|
|
2888
|
-
});
|
|
2889
|
-
|
|
2890
|
-
_logger.set(this, {
|
|
2891
|
-
writable: true,
|
|
2892
|
-
value: void 0
|
|
2893
|
-
});
|
|
2894
|
-
|
|
2286
|
+
_classPrivateFieldInitSpec(this, _asyncStorage, void 0);
|
|
2287
|
+
_classPrivateFieldInitSpec(this, _logger, void 0);
|
|
2895
2288
|
if (logger) {
|
|
2896
|
-
|
|
2289
|
+
_classPrivateFieldSet2(_logger, this, logger);
|
|
2897
2290
|
}
|
|
2898
|
-
|
|
2899
|
-
|
|
2900
|
-
|
|
2901
|
-
_classPrivateFieldSet(this, _hasATokenBeenGenerated, false);
|
|
2902
|
-
|
|
2291
|
+
_classPrivateFieldSet2(_tokenGenerator, this, tokenGenerator);
|
|
2292
|
+
_classPrivateFieldSet2(_hasATokenBeenGenerated, this, false);
|
|
2903
2293
|
this.setAsyncStorage(asyncStorage);
|
|
2904
2294
|
this.accessTokenKey = accessTokenKey;
|
|
2905
2295
|
this.handleTokenResponse = this.handleTokenResponse.bind(this);
|
|
2906
2296
|
this.generateToken = memoizePromise(this.generateToken);
|
|
2907
2297
|
this.refreshToken = memoizePromise(this.refreshToken);
|
|
2908
2298
|
}
|
|
2909
|
-
|
|
2910
|
-
_createClass(TokenStorage, [{
|
|
2299
|
+
return _createClass(TokenStorage, [{
|
|
2911
2300
|
key: "setAsyncStorage",
|
|
2912
2301
|
value: function setAsyncStorage(asyncStorage) {
|
|
2913
|
-
|
|
2302
|
+
_classPrivateFieldSet2(_asyncStorage, this, asyncStorage);
|
|
2914
2303
|
}
|
|
2915
2304
|
}, {
|
|
2916
2305
|
key: "hasAccessToken",
|
|
2917
2306
|
value: function hasAccessToken() {
|
|
2918
|
-
return
|
|
2307
|
+
return _classPrivateFieldGet2(_asyncStorage, this).getItem(this.accessTokenKey).then(function (accessToken) {
|
|
2919
2308
|
return !!accessToken;
|
|
2920
2309
|
});
|
|
2921
2310
|
}
|
|
@@ -2930,33 +2319,27 @@
|
|
|
2930
2319
|
key: "getAccessTokenObject",
|
|
2931
2320
|
value: function getAccessTokenObject() {
|
|
2932
2321
|
var _this = this;
|
|
2933
|
-
|
|
2934
|
-
return _classPrivateFieldGet(this, _asyncStorage).getItem(this.accessTokenKey).then(function (token) {
|
|
2322
|
+
return _classPrivateFieldGet2(_asyncStorage, this).getItem(this.accessTokenKey).then(function (token) {
|
|
2935
2323
|
if (token) {
|
|
2936
2324
|
var tokenObject = JSON.parse(token);
|
|
2937
|
-
|
|
2938
2325
|
if (_typeof(tokenObject) !== 'object') {
|
|
2939
2326
|
return null;
|
|
2940
2327
|
}
|
|
2941
|
-
|
|
2942
2328
|
return tokenObject;
|
|
2943
2329
|
}
|
|
2944
|
-
|
|
2945
|
-
if (_classPrivateFieldGet(_this, _hasATokenBeenGenerated)) {
|
|
2330
|
+
if (_classPrivateFieldGet2(_hasATokenBeenGenerated, _this)) {
|
|
2946
2331
|
return null;
|
|
2947
2332
|
}
|
|
2948
|
-
|
|
2949
|
-
|
|
2950
|
-
return _classPrivateFieldGet(_this, _tokenGenerator).autoGenerateToken();
|
|
2333
|
+
if (typeof _classPrivateFieldGet2(_tokenGenerator, _this).autoGenerateToken === 'function') {
|
|
2334
|
+
return _classPrivateFieldGet2(_tokenGenerator, _this).autoGenerateToken();
|
|
2951
2335
|
}
|
|
2952
|
-
|
|
2953
2336
|
throw new Error('No token has been generated yet.');
|
|
2954
2337
|
});
|
|
2955
2338
|
}
|
|
2956
2339
|
}, {
|
|
2957
2340
|
key: "logout",
|
|
2958
2341
|
value: function logout() {
|
|
2959
|
-
return
|
|
2342
|
+
return _classPrivateFieldGet2(_asyncStorage, this).removeItem(this.accessTokenKey);
|
|
2960
2343
|
}
|
|
2961
2344
|
}, {
|
|
2962
2345
|
key: "_addExpiresAtToResponseData",
|
|
@@ -2964,30 +2347,25 @@
|
|
|
2964
2347
|
if (!responseData) {
|
|
2965
2348
|
return responseData;
|
|
2966
2349
|
}
|
|
2967
|
-
|
|
2968
2350
|
var updatedResponseData = _objectSpread2(_objectSpread2({}, responseData), {}, {
|
|
2969
2351
|
expires_at: null
|
|
2970
2352
|
});
|
|
2971
|
-
|
|
2972
|
-
|
|
2353
|
+
if (typeof updatedResponseData.expires_in !== 'undefined' && updatedResponseData.expires_in !== null
|
|
2354
|
+
// && updatedResponseData.expires_in >= 0
|
|
2973
2355
|
) {
|
|
2974
|
-
|
|
2975
|
-
|
|
2976
|
-
|
|
2356
|
+
updatedResponseData.expires_at = Math.round(callTimestamp / 1000) + updatedResponseData.expires_in;
|
|
2357
|
+
}
|
|
2977
2358
|
return updatedResponseData;
|
|
2978
2359
|
}
|
|
2979
2360
|
}, {
|
|
2980
2361
|
key: "generateToken",
|
|
2981
2362
|
value: function generateToken(parameters) {
|
|
2982
2363
|
var _this2 = this;
|
|
2983
|
-
|
|
2984
2364
|
var callTimestamp = Date.now();
|
|
2985
|
-
return
|
|
2365
|
+
return _classPrivateFieldGet2(_tokenGenerator, this).generateToken(parameters).then(this.handleTokenResponse).then(function (body) {
|
|
2986
2366
|
var updatedResponseData = _this2._addExpiresAtToResponseData(body, callTimestamp);
|
|
2987
|
-
|
|
2988
2367
|
return _this2._storeAccessToken(updatedResponseData).then(function () {
|
|
2989
|
-
|
|
2990
|
-
|
|
2368
|
+
_classPrivateFieldSet2(_hasATokenBeenGenerated, _this2, true);
|
|
2991
2369
|
return updatedResponseData;
|
|
2992
2370
|
});
|
|
2993
2371
|
});
|
|
@@ -2996,12 +2374,10 @@
|
|
|
2996
2374
|
key: "refreshToken",
|
|
2997
2375
|
value: function refreshToken() {
|
|
2998
2376
|
var _this3 = this;
|
|
2999
|
-
|
|
3000
|
-
return _classPrivateFieldGet(this, _asyncStorage).getItem(this.accessTokenKey).then(function (token) {
|
|
2377
|
+
return _classPrivateFieldGet2(_asyncStorage, this).getItem(this.accessTokenKey).then(function (token) {
|
|
3001
2378
|
var callTimestamp = Date.now();
|
|
3002
|
-
return
|
|
2379
|
+
return _classPrivateFieldGet2(_tokenGenerator, _this3).refreshToken(token ? JSON.parse(token) : null).then(_this3.handleTokenResponse).then(function (body) {
|
|
3003
2380
|
var updatedResponseData = _this3._addExpiresAtToResponseData(body, callTimestamp);
|
|
3004
|
-
|
|
3005
2381
|
return _this3._storeAccessToken(updatedResponseData).then(function () {
|
|
3006
2382
|
return updatedResponseData;
|
|
3007
2383
|
});
|
|
@@ -3014,11 +2390,9 @@
|
|
|
3014
2390
|
if (isResponse(responseOrBody)) {
|
|
3015
2391
|
var response = responseOrBody;
|
|
3016
2392
|
var originalResponse = response.clone();
|
|
3017
|
-
|
|
3018
|
-
|
|
3019
|
-
_classPrivateFieldGet(this, _logger).logResponse(response);
|
|
2393
|
+
if (_classPrivateFieldGet2(_logger, this)) {
|
|
2394
|
+
_classPrivateFieldGet2(_logger, this).logResponse(response);
|
|
3020
2395
|
}
|
|
3021
|
-
|
|
3022
2396
|
return response.json().then(function (body) {
|
|
3023
2397
|
if (isOauthError(body)) {
|
|
3024
2398
|
// throw error if response body is an oauth error
|
|
@@ -3027,31 +2401,26 @@
|
|
|
3027
2401
|
// throw an error if response status code is an "error" status code
|
|
3028
2402
|
throw getHttpErrorFromResponse(originalResponse);
|
|
3029
2403
|
}
|
|
3030
|
-
|
|
3031
2404
|
return body;
|
|
3032
2405
|
})["catch"](function (err) {
|
|
3033
2406
|
if (!(err instanceof OauthError)) {
|
|
3034
2407
|
throw new OauthError(err.type, getHttpErrorFromResponse(originalResponse));
|
|
3035
2408
|
}
|
|
3036
|
-
|
|
3037
2409
|
throw err;
|
|
3038
2410
|
});
|
|
3039
2411
|
}
|
|
3040
|
-
|
|
3041
2412
|
var body = responseOrBody;
|
|
3042
|
-
|
|
3043
2413
|
if (isOauthError(body)) {
|
|
3044
2414
|
// throw error if response body is an oauth error
|
|
3045
2415
|
manageOauthError(body);
|
|
3046
2416
|
}
|
|
3047
|
-
|
|
3048
2417
|
return Promise.resolve(body);
|
|
3049
2418
|
}
|
|
2419
|
+
|
|
3050
2420
|
/**
|
|
3051
2421
|
* Return the number of second when the token will expire
|
|
3052
2422
|
* return value can be negative if the token is already expired
|
|
3053
2423
|
*/
|
|
3054
|
-
|
|
3055
2424
|
}, {
|
|
3056
2425
|
key: "getCurrentTokenExpiresIn",
|
|
3057
2426
|
value: function getCurrentTokenExpiresIn() {
|
|
@@ -3059,11 +2428,9 @@
|
|
|
3059
2428
|
if (accessTokenObject === null) {
|
|
3060
2429
|
throw new Error('No token has been stored.');
|
|
3061
2430
|
}
|
|
3062
|
-
|
|
3063
2431
|
if (typeof accessTokenObject.expires_at === 'undefined' || accessTokenObject.expires_at === null) {
|
|
3064
2432
|
return null;
|
|
3065
2433
|
}
|
|
3066
|
-
|
|
3067
2434
|
var now = Math.round(Date.now() / 1000);
|
|
3068
2435
|
return accessTokenObject.expires_at - now;
|
|
3069
2436
|
});
|
|
@@ -3071,11 +2438,9 @@
|
|
|
3071
2438
|
}, {
|
|
3072
2439
|
key: "_storeAccessToken",
|
|
3073
2440
|
value: function _storeAccessToken(responseData) {
|
|
3074
|
-
return
|
|
2441
|
+
return _classPrivateFieldGet2(_asyncStorage, this).setItem(this.accessTokenKey, JSON.stringify(responseData));
|
|
3075
2442
|
}
|
|
3076
2443
|
}]);
|
|
3077
|
-
|
|
3078
|
-
return TokenStorage;
|
|
3079
2444
|
}();
|
|
3080
2445
|
|
|
3081
2446
|
exports.AbstractClient = AbstractClient;
|
|
@@ -3105,5 +2470,5 @@
|
|
|
3105
2470
|
|
|
3106
2471
|
Object.defineProperty(exports, '__esModule', { value: true });
|
|
3107
2472
|
|
|
3108
|
-
}))
|
|
2473
|
+
}));
|
|
3109
2474
|
//# sourceMappingURL=index.cjs.map
|