@nmshd/consumption 2.0.0-alpha.28 → 2.0.0-alpha.30

package/lib-web/nmshd.consumption.js

@@ -17,11 +17,11 @@ const content_1 = __webpack_require__(/*! @nmshd/content */ "@nmshd/content");
 const crypto_1 = __webpack_require__(/*! @nmshd/crypto */ "@nmshd/crypto");
 const transport_1 = __webpack_require__(/*! @nmshd/transport */ "@nmshd/transport");
 exports.buildInformation = {
-    version: "2.0.0-alpha.28",
-    build: "48",
-    date: "2022-07-07T13:12:39+00:00",
-    commit: "81c8304697f68fe9ed157cebc415dd1fb2f7b941",
-    dependencies: {"@js-soft/docdb-querytranslator":"^1.0.1","ts-simple-nameof":"^1.3.1"},
+    version: "2.0.0-alpha.30",
+    build: "50",
+    date: "2022-07-20T08:46:05+00:00",
+    commit: "c75ea75c8ea2648264f637a5d484f7937cd383f6",
+    dependencies: {"@js-soft/docdb-querytranslator":"^1.1.0","ts-simple-nameof":"^1.3.1"},
     libraries: {
         transport: transport_1.buildInformation,
         crypto: crypto_1.buildInformation,
@@ -1197,61 +1197,54 @@ exports.DecideRequestParametersValidator = void 0;
 const ts_utils_1 = __webpack_require__(/*! @js-soft/ts-utils */ "./node_modules/@js-soft/ts-utils/dist/index.js");
 const content_1 = __webpack_require__(/*! @nmshd/content */ "@nmshd/content");
 const transport_1 = __webpack_require__(/*! @nmshd/transport */ "@nmshd/transport");
+const ValidationResult_1 = __webpack_require__(/*! ../itemProcessors/ValidationResult */ "./dist/modules/requests/itemProcessors/ValidationResult.js");
 const DecideRequestItemGroupParameters_1 = __webpack_require__(/*! ./decide/DecideRequestItemGroupParameters */ "./dist/modules/requests/incoming/decide/DecideRequestItemGroupParameters.js");
 const DecideRequestItemParameters_1 = __webpack_require__(/*! ./decide/DecideRequestItemParameters */ "./dist/modules/requests/incoming/decide/DecideRequestItemParameters.js");
 class DecideRequestParametersValidator {
     validate(params, request) {
         if (!request.id.equals(transport_1.CoreId.from(params.requestId))) {
-            return ts_utils_1.Result.fail(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidRequestId", "The id of the request does not match the id of the response"));
+            return ValidationResult_1.ValidationResult.error(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidRequestId", "The id of the Request does not match the id of the Response"));
         }
         if (params.items.length !== request.content.items.length) {
-            return ts_utils_1.Result.fail(this.invalidNumberOfItemsError("Number of items in Request and Response do not match"));
-        }
-        for (let i = 0; i < params.items.length; i++) {
-            const validationResult = this.checkItemOrGroup(request.content.items[i], params.items[i], i.toString(), params.accept);
-            if (validationResult.isError)
-                return validationResult;
+            return ValidationResult_1.ValidationResult.error(this.invalidNumberOfItemsError("Number of items in Request and Response do not match"));
         }
-        return ts_utils_1.Result.ok(undefined);
+        const validationResults = request.content.items.map((requestItem, index) => this.checkItemOrGroup(requestItem, params.items[index], params.accept));
+        return ValidationResult_1.ValidationResult.fromItems(validationResults);
     }
-    checkItemOrGroup(requestItem, responseItem, index, isParentAccepted) {
+    checkItemOrGroup(requestItem, responseItem, isParentAccepted) {
         if (requestItem instanceof content_1.RequestItem) {
-            return this.checkItem(requestItem, responseItem, index, isParentAccepted);
+            return this.checkItem(requestItem, responseItem, isParentAccepted);
         }
-        return this.checkItemGroup(requestItem, responseItem, index, isParentAccepted);
+        return this.checkItemGroup(requestItem, responseItem, isParentAccepted);
     }
-    checkItem(requestItem, response, index, isParentAccepted) {
+    checkItem(requestItem, response, isParentAccepted) {
         if ((0, DecideRequestItemGroupParameters_1.isDecideRequestItemGroupParametersJSON)(response)) {
-            return ts_utils_1.Result.fail(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidResponseItemForRequestItem", `The RequestItem with index '${index}' was answered as a RequestItemGroup.`));
+            return ValidationResult_1.ValidationResult.error(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidResponseItemForRequestItem", "The RequestItem was answered as a RequestItemGroup."));
         }
         if (!isParentAccepted && response.accept) {
-            return ts_utils_1.Result.fail(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidResponseItemForRequestItem", `The RequestItem with index '${index}' was accepted, but the parent was not accepted.`));
+            return ValidationResult_1.ValidationResult.error(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidResponseItemForRequestItem", "The RequestItem was accepted, but the parent was not accepted."));
         }
         if (isParentAccepted && requestItem.mustBeAccepted && !response.accept) {
-            return ts_utils_1.Result.fail(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidResponseItemForRequestItem", `The RequestItem with index '${index}', which is flagged as 'mustBeAccepted', was not accepted.`));
+            return ValidationResult_1.ValidationResult.error(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidResponseItemForRequestItem", "The RequestItem is flagged as 'mustBeAccepted', but it was not accepted."));
         }
-        return ts_utils_1.Result.ok(undefined);
+        return ValidationResult_1.ValidationResult.success();
     }
-    checkItemGroup(requestItemGroup, responseItemGroup, index, isParentAccepted) {
+    checkItemGroup(requestItemGroup, responseItemGroup, isParentAccepted) {
         if ((0, DecideRequestItemParameters_1.isDecideRequestItemParametersJSON)(responseItemGroup)) {
-            return ts_utils_1.Result.fail(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidResponseItemForRequestItem", `The RequestItemGroup with index '${index}' was answered as a RequestItem.`));
+            return ValidationResult_1.ValidationResult.error(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidResponseItemForRequestItem", "The RequestItemGroup was answered as a RequestItem."));
         }
         if (responseItemGroup.items.length !== requestItemGroup.items.length) {
-            return ts_utils_1.Result.fail(this.invalidNumberOfItemsError("Number of items in RequestItemGroup and ResponseItemGroup do not match"));
+            return ValidationResult_1.ValidationResult.error(this.invalidNumberOfItemsError("Number of items in RequestItemGroup and ResponseItemGroup do not match"));
         }
         const isGroupAccepted = responseItemGroup.items.some((value) => value.accept);
         if (!isParentAccepted && isGroupAccepted) {
-            return ts_utils_1.Result.fail(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidResponseItemForRequestItem", `The RequestItemGroup with index '${index}' was accepted, but the parent was not accepted.`));
+            return ValidationResult_1.ValidationResult.error(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidResponseItemForRequestItem", "The RequestItemGroup was accepted, but the parent was not accepted."));
         }
         if (isParentAccepted && requestItemGroup.mustBeAccepted && !isGroupAccepted) {
-            return ts_utils_1.Result.fail(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidResponseItemForRequestItem", `The RequestItemGroup with index '${index}', which is flagged as 'mustBeAccepted', was not accepted. Please accept all 'mustBeAccepted' items in this group.`));
+            return ValidationResult_1.ValidationResult.error(new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidResponseItemForRequestItem", "The RequestItemGroup is flagged as 'mustBeAccepted', but it was not accepted. Please accept all 'mustBeAccepted' items in this group."));
         }
-        for (let i = 0; i < responseItemGroup.items.length; i++) {
-            const validationResult = this.checkItem(requestItemGroup.items[i], responseItemGroup.items[i], `${index}.${i}`, isGroupAccepted);
-            if (validationResult.isError)
-                return validationResult;
-        }
-        return ts_utils_1.Result.ok(undefined);
+        const validationResults = requestItemGroup.items.map((requestItem, index) => this.checkItem(requestItem, responseItemGroup.items[index], isGroupAccepted));
+        return ValidationResult_1.ValidationResult.fromItems(validationResults);
     }
     invalidNumberOfItemsError(message) {
         return new ts_utils_1.ApplicationError("error.requests.decide.validation.invalidNumberOfItems", message);
@@ -1380,11 +1373,10 @@ class IncomingRequestsController extends consumption_1.ConsumptionBaseController
         // syntactic validation
         InternalDecideRequestParameters_1.InternalDecideRequestParameters.from(params);
         const request = await this.getOrThrow(params.requestId);
-        const validationResult = this.decideRequestParamsValidator.validate(params, request);
-        if (!validationResult.isSuccess) {
-            throw new Error(validationResult.error.message);
-        }
         this.assertRequestStatus(request, LocalRequestStatus_1.LocalRequestStatus.DecisionRequired, LocalRequestStatus_1.LocalRequestStatus.ManualDecisionRequired);
+        const validationResult = this.decideRequestParamsValidator.validate(params, request);
+        if (validationResult.isError())
+            return validationResult;
         const itemResults = await this.canDecideItems(params.items, request.content.items, request);
         return ValidationResult_1.ValidationResult.fromItems(itemResults);
     }
@@ -2325,10 +2317,10 @@ const transport_1 = __webpack_require__(/*! @nmshd/transport */ "@nmshd/transpor
 const ts_simple_nameof_1 = __webpack_require__(/*! ts-simple-nameof */ "./node_modules/ts-simple-nameof/index.js");
 let AcceptReadAttributeRequestItemParameters = AcceptReadAttributeRequestItemParameters_1 = class AcceptReadAttributeRequestItemParameters extends ts_serval_1.Serializable {
     isWithExistingAttribute() {
-        return this.attributeId !== undefined;
+        return this.existingAttributeId !== undefined;
     }
     isWithNewAttribute() {
-        return this.newAttributeValue !== undefined;
+        return this.newAttribute !== undefined;
     }
     static from(value) {
         return this.fromAny(value);
@@ -2336,11 +2328,11 @@ let AcceptReadAttributeRequestItemParameters = AcceptReadAttributeRequestItemPar
     static postFrom(value) {
         if (!(value instanceof AcceptReadAttributeRequestItemParameters_1))
             throw new Error("this should never happen");
-        if (value.attributeId && value.newAttributeValue) {
-            throw new ts_serval_1.ValidationError(AcceptReadAttributeRequestItemParameters_1.name, (0, ts_simple_nameof_1.nameof)((x) => x.newAttributeValue), `You cannot specify both ${(0, ts_simple_nameof_1.nameof)((x) => x.newAttributeValue)} and ${(0, ts_simple_nameof_1.nameof)((x) => x.attributeId)}.`);
+        if (value.existingAttributeId && value.newAttribute) {
+            throw new ts_serval_1.ValidationError(AcceptReadAttributeRequestItemParameters_1.name, (0, ts_simple_nameof_1.nameof)((x) => x.newAttribute), `You cannot specify both ${(0, ts_simple_nameof_1.nameof)((x) => x.newAttribute)} and ${(0, ts_simple_nameof_1.nameof)((x) => x.existingAttributeId)}.`);
         }
-        if (!value.attributeId && !value.newAttributeValue) {
-            throw new ts_serval_1.ValidationError(AcceptReadAttributeRequestItemParameters_1.name, (0, ts_simple_nameof_1.nameof)((x) => x.newAttributeValue), `You have to specify either ${(0, ts_simple_nameof_1.nameof)((x) => x.newAttributeValue)} or ${(0, ts_simple_nameof_1.nameof)((x) => x.attributeId)}.`);
+        if (!value.existingAttributeId && !value.newAttribute) {
+            throw new ts_serval_1.ValidationError(AcceptReadAttributeRequestItemParameters_1.name, (0, ts_simple_nameof_1.nameof)((x) => x.newAttribute), `You have to specify either ${(0, ts_simple_nameof_1.nameof)((x) => x.newAttribute)} or ${(0, ts_simple_nameof_1.nameof)((x) => x.existingAttributeId)}.`);
         }
         return value;
     }
@@ -2349,12 +2341,12 @@ __decorate([
     (0, ts_serval_1.serialize)(),
     (0, ts_serval_1.validate)({ nullable: true }),
     __metadata("design:type", transport_1.CoreId)
-], AcceptReadAttributeRequestItemParameters.prototype, "attributeId", void 0);
+], AcceptReadAttributeRequestItemParameters.prototype, "existingAttributeId", void 0);
 __decorate([
     (0, ts_serval_1.serialize)({ unionTypes: [content_1.IdentityAttribute, content_1.RelationshipAttribute] }),
     (0, ts_serval_1.validate)({ nullable: true }),
     __metadata("design:type", Object)
-], AcceptReadAttributeRequestItemParameters.prototype, "newAttributeValue", void 0);
+], AcceptReadAttributeRequestItemParameters.prototype, "newAttribute", void 0);
 AcceptReadAttributeRequestItemParameters = AcceptReadAttributeRequestItemParameters_1 = __decorate([
     (0, ts_serval_1.type)("AcceptReadAttributeRequestItemParameters")
 ], AcceptReadAttributeRequestItemParameters);
@@ -2395,7 +2387,7 @@ class ReadAttributeRequestItemProcessor extends GenericRequestItemProcessor_1.Ge
     async canAccept(_requestItem, params, requestInfo) {
         const parsedParams = AcceptReadAttributeRequestItemParameters_1.AcceptReadAttributeRequestItemParameters.from(params);
         if (parsedParams.isWithExistingAttribute()) {
-            const foundAttribute = await this.consumptionController.attributes.getLocalAttribute(parsedParams.attributeId);
+            const foundAttribute = await this.consumptionController.attributes.getLocalAttribute(parsedParams.existingAttributeId);
             if (!foundAttribute) {
                 return ValidationResult_1.ValidationResult.error(transport_1.TransportErrors.general.recordNotFound(LocalAttribute_1.LocalAttribute, requestInfo.id.toString()));
             }
@@ -2409,10 +2401,10 @@ class ReadAttributeRequestItemProcessor extends GenericRequestItemProcessor_1.Ge
         const parsedParams = AcceptReadAttributeRequestItemParameters_1.AcceptReadAttributeRequestItemParameters.from(params);
         let sharedLocalAttribute;
         if (parsedParams.isWithExistingAttribute()) {
-            sharedLocalAttribute = await this.copyExistingAttribute(parsedParams.attributeId, requestInfo);
+            sharedLocalAttribute = await this.copyExistingAttribute(parsedParams.existingAttributeId, requestInfo);
         }
         else {
-            sharedLocalAttribute = await this.createNewAttribute(parsedParams.newAttributeValue, requestInfo);
+            sharedLocalAttribute = await this.createNewAttribute(parsedParams.newAttribute, requestInfo);
         }
         return content_1.ReadAttributeAcceptResponseItem.from({
             result: content_1.ResponseItemResult.Accepted,
@@ -2560,12 +2552,12 @@ class ShareAttributeRequestItemProcessor extends GenericRequestItemProcessor_1.G
         if (attribute.content instanceof content_1.IdentityAttribute) {
             return ((await this.consumptionController.attributes.getLocalAttributes({
                 "shareInfo.sourceAttribute": attribute.shareInfo.sourceAttribute.toString(),
-                "shareInfo.peer": shareWith.toString() // eslint-disable-line @typescript-eslint/naming-convention
+                "shareInfo.peer": shareWith.toString()
             })).length > 0);
         }
         return ((await this.consumptionController.attributes.getLocalAttributes({
             "shareInfo.sourceAttribute": attribute.id.toString(),
-            "shareInfo.peer": shareWith.toString() // eslint-disable-line @typescript-eslint/naming-convention
+            "shareInfo.peer": shareWith.toString()
         })).length > 0);
     }
     async shareAttribute(attribute, shareWith) {
@@ -3529,7 +3521,7 @@ class QueryTranslator {
     valRegex;
     arrRegex;
     constructor(options = {}) {
-        this.ops = options.ops ?? ["!", "^", "$", "~", ">", "<", "$in"];
+        this.ops = options.ops ?? ["!", "^", "$", "~", ">", "<", "$containsAny", "$containsNone"];
         this.alias = options.alias ?? {};
         this.blacklist = options.blacklist ?? {};
         this.whitelist = options.whitelist ?? {};
@@ -3560,7 +3552,7 @@ class QueryTranslator {
         switch (op) {
             case "!":
                 if (array) {
-                    ret.field = "$nin";
+                    ret.field = "$containsNone";
                 }
                 else if (org === "") {
                     ret.field = "$exists";
@@ -3598,7 +3590,7 @@ class QueryTranslator {
                 ret.op = op = "";
                 ret.value = this.parseStringVal(org);
                 if (array) {
-                    ret.field = "$in";
+                    ret.field = "$containsAny";
                 }
                 else if (org === "") {
                     ret.field = "$exists";
@@ -3665,14 +3657,14 @@ class QueryTranslator {
             }
             // Handle array key
             if (Array.isArray(val)) {
-                if (this.ops.includes("$in") && val.length > 0) {
+                if (this.ops.includes("$containsAny") && val.length > 0) {
                     res[key] = {};
                     for (const item of val) {
                         if (this.ops.includes(item[0])) {
                             const parsed = this.parseString(item, true);
                             switch (parsed.field) {
-                                case "$in":
-                                case "$nin":
+                                case "$containsAny":
+                                case "$containsNone":
                                     res[key][parsed.field] = res[key][parsed.field] || [];
                                     res[key][parsed.field].push(parsed.value);
                                     break;
@@ -3685,8 +3677,8 @@ class QueryTranslator {
                             }
                         }
                         else {
-                            res[key].$in = res[key].$in || [];
-                            res[key].$in.push(this.parseStringVal(item));
+                            res[key].$containsAny = res[key].$containsAny || [];
+                            res[key].$containsAny.push(this.parseStringVal(item));
                         }
                     }
                 }
@@ -3831,10 +3823,11 @@ const EventBus_1 = __webpack_require__(/*! ../EventBus */ "./node_modules/@js-so
 const SubscriptionTargetInfo_1 = __webpack_require__(/*! ../SubscriptionTargetInfo */ "./node_modules/@js-soft/ts-utils/dist/eventBus/SubscriptionTargetInfo.js");
 class EventEmitter2EventBus {
     emitter;
-    wrappers = new Map();
+    listeners = new Map();
     nextId = 0;
-    constructor() {
-        this.emitter = new eventemitter2_1.EventEmitter2({ wildcard: true, maxListeners: 50, verboseMemoryLeak: true });
+    invocationPromises = [];
+    constructor(options) {
+        this.emitter = new eventemitter2_1.EventEmitter2({ ...options, wildcard: true, maxListeners: 50, verboseMemoryLeak: true });
     }
     subscribe(subscriptionTarget, handler) {
         return this.registerHandler(subscriptionTarget, handler);
@@ -3842,33 +3835,39 @@ class EventEmitter2EventBus {
     subscribeOnce(subscriptionTarget, handler) {
         return this.registerHandler(subscriptionTarget, handler, true);
     }
-    unsubscribe(subscriptionTarget, subscriptionId) {
-        return this.unregisterHandler(subscriptionTarget, subscriptionId);
+    unsubscribe(subscriptionId) {
+        return this.unregisterHandler(subscriptionId);
     }
     registerHandler(subscriptionTarget, handler, isOneTimeHandler = false) {
         const subscriptionTargetInfo = SubscriptionTargetInfo_1.SubscriptionTargetInfo.from(subscriptionTarget);
-        const handlerId = this.nextId++;
-        const handlerWrapper = (event) => {
+        const listenerId = this.nextId++;
+        const handlerWrapper = async (event) => {
             if (!subscriptionTargetInfo.isCompatibleWith(event)) {
                 return;
             }
-            handler(event);
-            if (isOneTimeHandler) {
-                this.unsubscribe(subscriptionTarget, handlerId);
-            }
+            const invocationPromise = (async () => await handler(event))();
+            this.invocationPromises.push(invocationPromise);
+            await invocationPromise;
+            this.invocationPromises = this.invocationPromises.filter((p) => p !== invocationPromise);
+            if (isOneTimeHandler)
+                this.listeners.delete(listenerId);
         };
-        this.wrappers.set(handlerId, handlerWrapper);
-        this.emitter.on(subscriptionTargetInfo.namespace, handlerWrapper);
-        return handlerId;
-    }
-    unregisterHandler(subscriptionTarget, handlerId) {
-        const subscriptionTargetInfo = SubscriptionTargetInfo_1.SubscriptionTargetInfo.from(subscriptionTarget);
-        const handlerWrapper = this.wrappers.get(handlerId);
-        if (!handlerWrapper) {
+        if (isOneTimeHandler) {
+            const listener = this.emitter.once(subscriptionTargetInfo.namespace, handlerWrapper, { objectify: true });
+            this.listeners.set(listenerId, listener);
+            return listenerId;
+        }
+        const listener = this.emitter.on(subscriptionTargetInfo.namespace, handlerWrapper, { objectify: true });
+        this.listeners.set(listenerId, listener);
+        return listenerId;
+    }
+    unregisterHandler(listenerId) {
+        const listener = this.listeners.get(listenerId);
+        if (!listener) {
             return false;
         }
-        this.emitter.off(subscriptionTargetInfo.namespace, handlerWrapper);
-        this.wrappers.delete(handlerId);
+        listener.off();
+        this.listeners.delete(listenerId);
         return true;
     }
     publish(event) {
@@ -3878,6 +3877,24 @@ class EventEmitter2EventBus {
         }
         this.emitter.emit(namespace, event);
     }
+    async close(timeout) {
+        this.emitter.removeAllListeners();
+        const waitForInvocations = Promise.all(this.invocationPromises).catch(() => {
+            /* ignore errors */
+        });
+        if (!timeout) {
+            await waitForInvocations;
+            return;
+        }
+        let timeoutId;
+        const timeoutPromise = new Promise((_, reject) => {
+            timeoutId = setTimeout(() => {
+                reject(new Error("timeout exceeded while waiting for events to process"));
+            }, timeout);
+        });
+        await Promise.race([waitForInvocations, timeoutPromise]);
+        clearTimeout(timeoutId);
+    }
 }
 exports.EventEmitter2EventBus = EventEmitter2EventBus;
 //# sourceMappingURL=EventEmitter2EventBus.js.map