@twin.org/rights-management-plugins 0.0.3-next.53 → 0.0.3-next.55

package/dist/es/models/IStaticPolicyInformationSource.js.map

@@ -1 +1 @@
-{"version":3,"file":"IStaticPolicyInformationSource.js","sourceRoot":"","sources":["../../../src/models/IStaticPolicyInformationSource.ts"],"names":[],"mappings":"","sourcesContent":["// Copyright 2025 IOTA Stiftung.\n// SPDX-License-Identifier: Apache-2.0.\nimport type { IJsonLdNodeObject } from \"@twin.org/data-json-ld\";\nimport type { PolicyInformationAccessMode } from \"@twin.org/rights-management-models\";\n\n/**\n * Configuration for the Static Policy Information Source Component.\n */\nexport interface IStaticPolicyInformationSource {\n\t/**\n\t * Is the information public, if so it will be shared with negotiation requests.\n\t */\n\taccessMode: PolicyInformationAccessMode;\n\n\t/**\n\t * Information is only provided for the specified locator combination.\n\t */\n\tmatchLocators?: {\n\t\tassignee?: string;\n\t\tassigner?: string;\n\t\ttarget?: string;\n\t\taction?: string;\n\t}[];\n\n\t/**\n\t * The objects containing the information.\n\t */\n\tobjects: { [id: string]: IJsonLdNodeObject };\n}\n"]}
+{"version":3,"file":"IStaticPolicyInformationSource.js","sourceRoot":"","sources":["../../../src/models/IStaticPolicyInformationSource.ts"],"names":[],"mappings":"","sourcesContent":["// Copyright 2025 IOTA Stiftung.\n// SPDX-License-Identifier: Apache-2.0.\nimport type {\n\tIRightsManagementInformation,\n\tPolicyInformationAccessMode\n} from \"@twin.org/rights-management-models\";\n\n/**\n * Configuration for the Static Policy Information Source Component.\n */\nexport interface IStaticPolicyInformationSource {\n\t/**\n\t * Is the information public, if so it will be shared with negotiation requests.\n\t */\n\taccessMode: PolicyInformationAccessMode;\n\n\t/**\n\t * Information is only provided for the specified locator combination.\n\t */\n\tmatchLocators?: {\n\t\tassignee?: string;\n\t\tassigner?: string;\n\t\ttarget?: string;\n\t\taction?: string;\n\t}[];\n\n\t/**\n\t * The objects containing the information.\n\t */\n\tobjects: IRightsManagementInformation;\n}\n"]}

package/dist/es/policyArbiters/defaultPolicyArbiter.js

@@ -1,9 +1,9 @@
 // Copyright 2025 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
-import { ArrayHelper, Coerce, ComponentFactory, GeneralError, Guards, Is, ObjectHelper, StringHelper } from "@twin.org/core";
+import { ArrayHelper, Coerce, ComponentFactory, Duration, GeneralError, Guards, Is, ObjectHelper, StringHelper } from "@twin.org/core";
 import { JsonPathHelper } from "@twin.org/data-json-path";
 import { OdrlPolicyHelper, OdrlProfiles, PolicyDecision, PolicyObligationEnforcerFactory } from "@twin.org/rights-management-models";
-import { OdrlConflictStrategyType, OdrlLogicalConstraintType, OdrlOperatorType, OdrlTypes } from "@twin.org/standards-w3c-odrl";
+import { OdrlConflictStrategyType, OdrlLeftOperandType, OdrlLogicalConstraintType, OdrlOperatorType, OdrlTypes } from "@twin.org/standards-w3c-odrl";
 /**
  * Default Policy Arbiter.
  */
@@ -1244,8 +1244,8 @@ export class DefaultPolicyArbiter {
             throw new GeneralError(DefaultPolicyArbiter.CLASS_NAME, "constraintStatusNotSupported");
         }
         // Evaluate the main constraint condition
-        const leftValue = this.calculateOperandValue(regularConstraint.leftOperand, dataSources, regularConstraint);
-        const rightValue = this.calculateOperandValue(regularConstraint.rightOperand, dataSources, regularConstraint);
+        const leftValue = this.calculateOperandValue(regularConstraint.leftOperand, dataSources, regularConstraint, true);
+        const rightValue = this.calculateOperandValue(regularConstraint.rightOperand, dataSources, regularConstraint, false);
         const mainSatisfied = this.evaluateOperator(regularConstraint.operator, leftValue, rightValue);
         // If main constraint is not satisfied, the overall constraint fails
         return mainSatisfied;
@@ -1396,10 +1396,12 @@ export class DefaultPolicyArbiter {
      * @param operand The operand.
      * @param dataSources The available prefixed operand sources.
      * @param constraint Optional constraint providing additional context for operand resolution.
+     * @param isLeftOperand True when resolving the left operand of the constraint.
      * @returns The resolved operand value.
+     * @throws GeneralError When a known ODRL built-in left operand cannot be resolved.
      * @internal
      */
-    calculateOperandValue(operand, dataSources, constraint) {
+    calculateOperandValue(operand, dataSources, constraint, isLeftOperand) {
         let jsonPath;
         let operandRoot;
         if (Is.stringValue(operand)) {
@@ -1417,6 +1419,30 @@ export class DefaultPolicyArbiter {
                 jsonPath = lookup.jsonPath;
                 operandRoot = lookup.source;
             }
+            else {
+                const builtIn = this.resolveOdrlBuiltInLeftOperand(operand);
+                if (!Is.undefined(builtIn)) {
+                    return builtIn;
+                }
+                if (isLeftOperand) {
+                    if (this.operatorSupportsInformationLookup(constraint?.operator)) {
+                        const infoResult = this.resolveInformationKeyOperand(operand, dataSources);
+                        if (infoResult.found) {
+                            return infoResult.value;
+                        }
+                        if (this.isKnownOdrlBuiltInOperand(operand)) {
+                            throw new GeneralError(DefaultPolicyArbiter.CLASS_NAME, "leftOperandNotSupported", {
+                                leftOperand: operand
+                            });
+                        }
+                    }
+                    else if (this.isKnownOdrlBuiltInOperand(operand)) {
+                        throw new GeneralError(DefaultPolicyArbiter.CLASS_NAME, "leftOperandNotSupported", {
+                            leftOperand: operand
+                        });
+                    }
+                }
+            }
         }
         else if (Is.object(operand)) {
             const typedOperand = operand;
@@ -1560,9 +1586,9 @@ export class DefaultPolicyArbiter {
         const leftValues = ArrayHelper.fromObjectOrArray(left ?? []);
         switch (operator) {
             case OdrlOperatorType.Eq:
-                return leftValues.some(v => ObjectHelper.equal(v, right, false));
+                return leftValues.some(v => ObjectHelper.equal(v, right, false) || this.compareDurationEq(v, right));
             case OdrlOperatorType.Neq:
-                return leftValues.every(v => !ObjectHelper.equal(v, right, false));
+                return leftValues.every(v => !ObjectHelper.equal(v, right, false) && !this.compareDurationEq(v, right));
             case OdrlOperatorType.Gt:
                 return leftValues.some(v => this.compareOrdered(v, right, (a, b) => a > b));
             case OdrlOperatorType.Gteq:
@@ -1583,7 +1609,10 @@ export class DefaultPolicyArbiter {
                 return ObjectHelper.equal(leftValues, ArrayHelper.fromObjectOrArray(right) ?? [], false);
             }
             case OdrlOperatorType.IsNoneOf: {
-                return leftValues.every(v => !(ArrayHelper.fromObjectOrArray(right) ?? []).includes(v));
+                return leftValues.every(v => {
+                    const stringValue = Is.string(v) || Is.number(v) || Is.boolean(v) ? String(v) : JSON.stringify(v);
+                    return !(ArrayHelper.fromObjectOrArray(right) ?? []).includes(stringValue);
+                });
             }
             case OdrlOperatorType.LocTimeEq:
                 return leftValues.some(v => ObjectHelper.equal(v, right, false));
@@ -1618,6 +1647,11 @@ export class DefaultPolicyArbiter {
         if (!Is.undefined(leftDate) && !Is.undefined(rightDate)) {
             return compare(leftDate.getTime(), rightDate.getTime());
         }
+        const leftDuration = Coerce.duration(left);
+        const rightDuration = Coerce.duration(right);
+        if (!Is.undefined(leftDuration) && !Is.undefined(rightDuration)) {
+            return compare(Duration.toSeconds(leftDuration), Duration.toSeconds(rightDuration));
+        }
         // Only use string ordering when both operands are actual strings.
         // Avoid coercing other types into strings, as that can cause
         // unintended comparisons like 18 >= "$.minAge" evaluating to true.
@@ -1626,6 +1660,84 @@ export class DefaultPolicyArbiter {
         }
         return false;
     }
+    /**
+     * Test whether two values are equal when interpreted as ISO 8601 durations.
+     * Returns false if either side cannot be coerced to a duration.
+     * @param left The left value.
+     * @param right The right value.
+     * @returns True when both sides represent the same duration in seconds.
+     * @internal
+     */
+    compareDurationEq(left, right) {
+        const leftDuration = Coerce.duration(left);
+        const rightDuration = Coerce.duration(right);
+        if (!Is.undefined(leftDuration) && !Is.undefined(rightDuration)) {
+            return Duration.toSeconds(leftDuration) === Duration.toSeconds(rightDuration);
+        }
+        return false;
+    }
+    /**
+     * Resolve an ODRL built-in left operand to its runtime value.
+     * Returns the resolved value for natively-handled operands and undefined for all others.
+     * Callers are responsible for throwing when an unresolved known built-in is unacceptable.
+     * @param operand The left operand string.
+     * @returns The resolved value, or undefined when the operand has no native resolution.
+     * @internal
+     */
+    resolveOdrlBuiltInLeftOperand(operand) {
+        if (operand === OdrlLeftOperandType.DateTime) {
+            return new Date();
+        }
+        return undefined;
+    }
+    /**
+     * Determine whether the operand string is a recognised ODRL built-in left operand.
+     * @param operand The operand string to test.
+     * @returns True when the operand appears in the OdrlLeftOperandType vocabulary.
+     * @internal
+     */
+    isKnownOdrlBuiltInOperand(operand) {
+        return Object.values(OdrlLeftOperandType).includes(operand);
+    }
+    /**
+     * Determine whether the operator supports resolving left operands from the information object.
+     * Value-comparison and set operators are supported; structural/relationship operators are not.
+     * @param operator The operator to test.
+     * @returns True when information-key lookup is appropriate for this operator.
+     * @internal
+     */
+    operatorSupportsInformationLookup(operator) {
+        switch (operator) {
+            case OdrlOperatorType.Eq:
+            case OdrlOperatorType.Neq:
+            case OdrlOperatorType.Gt:
+            case OdrlOperatorType.Gteq:
+            case OdrlOperatorType.Lt:
+            case OdrlOperatorType.Lteq:
+            case OdrlOperatorType.IsAnyOf:
+            case OdrlOperatorType.IsAllOf:
+            case OdrlOperatorType.IsNoneOf:
+            case OdrlOperatorType.LocTimeEq:
+            case OdrlOperatorType.LocTimeGteq:
+                return true;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Attempt to resolve a left operand string as a key in the information object.
+     * @param operand The left operand string.
+     * @param dataSources The available data sources.
+     * @returns An object indicating whether the key was found and its value when present.
+     * @internal
+     */
+    resolveInformationKeyOperand(operand, dataSources) {
+        const information = dataSources[DefaultPolicyArbiter._INFORMATION_SOURCE_KEY];
+        if (Is.object(information) && !Is.empty(information[operand])) {
+            return { found: true, value: information[operand] };
+        }
+        return { found: false };
+    }
     /**
      * Coerce a value to a specific XSD type.
      * @param value The value to coerce.
@@ -1666,6 +1778,12 @@ export class DefaultPolicyArbiter {
             // Handle standard xsd types
             return Coerce.dateTime(value);
         }
+        else if (type === "xsd:duration") {
+            // Handle standard xsd types - convert to total seconds for ordered comparison.
+            // Falls back to numeric coercion for non-ISO values (e.g. bare seconds as a number).
+            const dur = Coerce.duration(value);
+            return Is.undefined(dur) ? Coerce.number(value) : Duration.toSeconds(dur);
+        }
         return undefined;
     }
 }