@authup/access 1.0.0-beta.25 → 1.0.0-beta.27

package/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2021-2025 Peter Placzek
+   Copyright 2021-2025 Peter Placzek <peter.placzek1996@gmail.com>
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/dist/index.cjs

@@ -86,30 +86,30 @@ class AttributeNamesPolicyValidator extends validup.Container {
 
 class AttributeNamesPolicyEvaluator {
     async can(ctx) {
-        return ctx.spec.type === BuiltInPolicyType.ATTRIBUTE_NAMES;
+        return ctx.config.type === BuiltInPolicyType.ATTRIBUTE_NAMES;
     }
-    async validateSpecification(ctx) {
-        return this.validator.run(ctx.spec);
+    async validateConfig(ctx) {
+        return this.validator.run(ctx.config);
     }
-    async validateData(ctx) {
-        if (!kit.isObject(ctx.data.attributes)) {
+    async validateInput(ctx) {
+        if (!kit.isObject(ctx.input.attributes)) {
             throw PolicyError.evaluatorContextInvalid();
         }
-        return ctx.data;
+        return ctx.input;
     }
     async evaluate(ctx) {
-        if (!ctx.data.attributes) {
+        if (!ctx.input.attributes) {
             throw PolicyError.evaluatorContextInvalid();
         }
-        const attributes = kit.flattenObject(ctx.data.attributes);
+        const attributes = kit.flattenObject(ctx.input.attributes);
         const keys = Object.keys(attributes);
         for(let i = 0; i < keys.length; i++){
-            const index = ctx.spec.names.indexOf(keys[i]);
+            const index = ctx.config.names.indexOf(keys[i]);
             if (index === -1) {
-                return maybeInvertPolicyOutcome(false, ctx.spec.invert);
+                return maybeInvertPolicyOutcome(false, ctx.config.invert);
             }
         }
-        return maybeInvertPolicyOutcome(true, ctx.spec.invert);
+        return maybeInvertPolicyOutcome(true, ctx.config.invert);
     }
     constructor(){
         this.validator = new AttributeNamesPolicyValidator();
@@ -135,24 +135,24 @@ class AttributesPolicyValidator extends validup.Container {
 
 class AttributesPolicyEvaluator {
     async can(ctx) {
-        return ctx.spec.type === BuiltInPolicyType.ATTRIBUTES;
+        return ctx.config.type === BuiltInPolicyType.ATTRIBUTES;
     }
-    async validateSpecification(ctx) {
-        return this.validator.run(ctx.spec);
+    async validateConfig(ctx) {
+        return this.validator.run(ctx.config);
     }
-    async validateData(ctx) {
-        if (!kit.isObject(ctx.data.attributes)) {
+    async validateInput(ctx) {
+        if (!kit.isObject(ctx.input.attributes)) {
             throw PolicyError.evaluatorContextInvalid();
         }
-        return ctx.data;
+        return ctx.input;
     }
     async evaluate(ctx) {
-        if (!ctx.data.attributes) {
+        if (!ctx.input.attributes) {
             throw PolicyError.evaluatorContextInvalid();
         }
-        this.fixQuery(ctx.spec.query);
-        const testIt = mongo2js.guard(ctx.spec.query);
-        return maybeInvertPolicyOutcome(testIt(ctx.data.attributes), ctx.spec.invert);
+        this.fixQuery(ctx.config.query);
+        const testIt = mongo2js.guard(ctx.config.query);
+        return maybeInvertPolicyOutcome(testIt(ctx.input.attributes), ctx.config.invert);
     }
     fixQuery(query) {
         const keys = Object.keys(query);
@@ -240,31 +240,31 @@ class PolicyDataValidator extends validup.Container {
 }
 
 async function evaluatePolicy(ctx) {
-    if (ctx.options.exclude && ctx.options.exclude.length > 0 && ctx.options.exclude.indexOf(ctx.spec.type) !== -1) {
-        if (typeof ctx.spec.invert === 'boolean') {
-            return maybeInvertPolicyOutcome(true, ctx.spec.invert);
+    if (ctx.options.exclude && ctx.options.exclude.length > 0 && ctx.options.exclude.indexOf(ctx.config.type) !== -1) {
+        if (typeof ctx.config.invert === 'boolean') {
+            return maybeInvertPolicyOutcome(true, ctx.config.invert);
         }
         return true;
     }
-    if (ctx.options.include && ctx.options.include.length > 0 && ctx.options.include.indexOf(ctx.spec.type) === -1) {
-        if (typeof ctx.spec.invert === 'boolean') {
-            return maybeInvertPolicyOutcome(true, ctx.spec.invert);
+    if (ctx.options.include && ctx.options.include.length > 0 && ctx.options.include.indexOf(ctx.config.type) === -1) {
+        if (typeof ctx.config.invert === 'boolean') {
+            return maybeInvertPolicyOutcome(true, ctx.config.invert);
         }
         return true;
     }
-    const evaluator = ctx.evaluators[ctx.spec.type];
+    const evaluator = ctx.evaluators[ctx.config.type];
     if (!evaluator) {
-        throw PolicyError.evaluatorNotFound(ctx.spec.type);
+        throw PolicyError.evaluatorNotFound(ctx.config.type);
     }
     try {
         const canEvaluate = await evaluator.can(ctx);
         if (canEvaluate) {
-            const spec = await evaluator.validateSpecification(ctx);
-            const data = await evaluator.validateData(ctx);
+            const config = await evaluator.validateConfig(ctx);
+            const input = await evaluator.validateInput(ctx);
             return await evaluator.evaluate({
                 ...ctx,
-                data,
-                spec
+                input,
+                config
             });
         }
     } catch (e) {
@@ -298,44 +298,44 @@ class CompositePolicyValidator extends validup.Container {
 
 class CompositePolicyEvaluator {
     async can(ctx) {
-        return isCompositePolicy(ctx.spec);
+        return isCompositePolicy(ctx.config);
     }
-    async validateSpecification(ctx) {
-        return this.validator.run(ctx.spec);
+    async validateConfig(ctx) {
+        return this.validator.run(ctx.config);
     }
-    async validateData(ctx) {
-        return ctx.data;
+    async validateInput(ctx) {
+        return ctx.input;
     }
     async evaluate(ctx) {
         let count = 0;
-        const decisionStrategy = ctx.spec.decisionStrategy ?? DecisionStrategy.UNANIMOUS;
-        for(let i = 0; i < ctx.spec.children.length; i++){
-            const childPolicy = ctx.spec.children[i];
+        const decisionStrategy = ctx.config.decisionStrategy ?? DecisionStrategy.UNANIMOUS;
+        for(let i = 0; i < ctx.config.children.length; i++){
+            const childPolicy = ctx.config.children[i];
             let outcome;
             if (isCompositePolicy(childPolicy)) {
                 outcome = await this.evaluate({
                     ...ctx,
-                    spec: childPolicy
+                    config: childPolicy
                 });
             } else {
                 outcome = await evaluatePolicy({
                     ...ctx,
-                    spec: childPolicy
+                    config: childPolicy
                 });
             }
             if (outcome) {
                 if (decisionStrategy === DecisionStrategy.AFFIRMATIVE) {
-                    return maybeInvertPolicyOutcome(true, ctx.spec.invert);
+                    return maybeInvertPolicyOutcome(true, ctx.config.invert);
                 }
                 count++;
             } else {
                 if (decisionStrategy === DecisionStrategy.UNANIMOUS) {
-                    return maybeInvertPolicyOutcome(false, ctx.spec.invert);
+                    return maybeInvertPolicyOutcome(false, ctx.config.invert);
                 }
                 count--;
             }
         }
-        return maybeInvertPolicyOutcome(count > 0, ctx.spec.invert);
+        return maybeInvertPolicyOutcome(count > 0, ctx.config.invert);
     }
     constructor(){
         this.validator = new CompositePolicyValidator();
@@ -365,34 +365,34 @@ function toDate$1(input) {
 }
 class DatePolicyEvaluator {
     async can(ctx) {
-        return ctx.spec.type === BuiltInPolicyType.DATE;
+        return ctx.config.type === BuiltInPolicyType.DATE;
     }
-    async validateSpecification(ctx) {
-        return this.validator.run(ctx.spec);
+    async validateConfig(ctx) {
+        return this.validator.run(ctx.config);
     }
-    async validateData(ctx) {
-        return ctx.data;
+    async validateInput(ctx) {
+        return ctx.input;
     }
     async evaluate(ctx) {
         let now;
-        if (ctx.data.dateTime) {
-            now = normalizeDate$1(toDate$1(ctx.data.dateTime));
+        if (ctx.input.dateTime) {
+            now = normalizeDate$1(toDate$1(ctx.input.dateTime));
         } else {
             now = normalizeDate$1(new Date());
         }
-        if (ctx.spec.start) {
-            const start = normalizeDate$1(toDate$1(ctx.spec.start));
+        if (ctx.config.start) {
+            const start = normalizeDate$1(toDate$1(ctx.config.start));
             if (now < start) {
-                return maybeInvertPolicyOutcome(false, ctx.spec.invert);
+                return maybeInvertPolicyOutcome(false, ctx.config.invert);
             }
         }
-        if (ctx.spec.end) {
-            const end = normalizeDate$1(toDate$1(ctx.spec.end));
+        if (ctx.config.end) {
+            const end = normalizeDate$1(toDate$1(ctx.config.end));
             if (now > end) {
-                return maybeInvertPolicyOutcome(false, ctx.spec.invert);
+                return maybeInvertPolicyOutcome(false, ctx.config.invert);
             }
         }
-        return maybeInvertPolicyOutcome(true, ctx.spec.invert);
+        return maybeInvertPolicyOutcome(true, ctx.config.invert);
     }
     constructor(){
         this.validator = new DatePolicyValidator();
@@ -408,24 +408,24 @@ class IdentityPolicyValidator extends validup.Container {
 
 class IdentityPolicyEvaluator {
     async can(ctx) {
-        return ctx.spec.type === BuiltInPolicyType.IDENTITY;
+        return ctx.config.type === BuiltInPolicyType.IDENTITY;
     }
-    async validateSpecification(ctx) {
-        return this.validator.run(ctx.spec);
+    async validateConfig(ctx) {
+        return this.validator.run(ctx.config);
     }
-    async validateData(ctx) {
-        return ctx.data;
+    async validateInput(ctx) {
+        return ctx.input;
     }
     async evaluate(ctx) {
-        if (!kit.isObject(ctx.data.identity)) {
-            return maybeInvertPolicyOutcome(false, ctx.spec.invert);
+        if (!kit.isObject(ctx.input.identity)) {
+            return maybeInvertPolicyOutcome(false, ctx.config.invert);
         }
-        const types = ctx.spec.types || [];
+        const types = ctx.config.types || [];
         if (types.length === 0) {
-            return maybeInvertPolicyOutcome(true, ctx.spec.invert);
+            return maybeInvertPolicyOutcome(true, ctx.config.invert);
         }
-        const typeAllowed = types.indexOf(ctx.data.identity.type) !== -1;
-        return maybeInvertPolicyOutcome(typeAllowed, ctx.spec.invert);
+        const typeAllowed = types.indexOf(ctx.input.identity.type) !== -1;
+        return maybeInvertPolicyOutcome(typeAllowed, ctx.config.invert);
     }
     constructor(){
         this.validator = new IdentityPolicyValidator();
@@ -438,20 +438,20 @@ class PermissionBindingPolicyValidator extends validup.Container {
 
 class PermissionBindingPolicyEvaluator {
     async can(ctx) {
-        return ctx.spec.type === BuiltInPolicyType.PERMISSION_BINDING;
+        return ctx.config.type === BuiltInPolicyType.PERMISSION_BINDING;
     }
-    async validateSpecification(ctx) {
-        return this.validator.run(ctx.spec);
+    async validateConfig(ctx) {
+        return this.validator.run(ctx.config);
     }
-    async validateData(ctx) {
-        if (!kit.isObject(ctx.data.identity) && !kit.isObject(ctx.data.permission)) {
+    async validateInput(ctx) {
+        if (!kit.isObject(ctx.input.identity) && !kit.isObject(ctx.input.permission)) {
             throw PolicyError.evaluatorContextInvalid();
         }
-        return ctx.data;
+        return ctx.input;
     }
     async evaluate(ctx) {
         // todo: this must be changed when the permission-checker not only checks owned permissions.
-        return maybeInvertPolicyOutcome(true, ctx.spec.invert);
+        return maybeInvertPolicyOutcome(true, ctx.config.invert);
     }
     constructor(){
         this.validator = new PermissionBindingPolicyValidator();
@@ -472,32 +472,32 @@ class RealmMatchPolicyValidator extends validup.Container {
 
 class RealmMatchPolicyEvaluator {
     async can(ctx) {
-        return ctx.spec.type === BuiltInPolicyType.REALM_MATCH;
+        return ctx.config.type === BuiltInPolicyType.REALM_MATCH;
     }
-    async validateSpecification(ctx) {
-        return this.validator.run(ctx.spec);
+    async validateConfig(ctx) {
+        return this.validator.run(ctx.config);
     }
-    async validateData(ctx) {
-        if (!kit.isObject(ctx.data.attributes) || !kit.isObject(ctx.data.identity)) {
+    async validateInput(ctx) {
+        if (!kit.isObject(ctx.input.attributes) || !kit.isObject(ctx.input.identity)) {
             throw PolicyError.evaluatorContextInvalid();
         }
-        return ctx.data;
+        return ctx.input;
     }
     async evaluate(ctx) {
-        if (!ctx.data.attributes || !ctx.data.identity) {
+        if (!ctx.input.attributes || !ctx.input.identity) {
             throw PolicyError.evaluatorContextInvalid();
         }
-        const identityMasterMatchAll = ctx.spec.identityMasterMatchAll ?? true;
-        if (identityMasterMatchAll && ctx.data.identity.realmName && ctx.data.identity.realmName === 'master') {
-            return maybeInvertPolicyOutcome(true, ctx.spec.invert);
+        const identityMasterMatchAll = ctx.config.identityMasterMatchAll ?? true;
+        if (identityMasterMatchAll && ctx.input.identity.realmName && ctx.input.identity.realmName === 'master') {
+            return maybeInvertPolicyOutcome(true, ctx.config.invert);
         }
         let keys;
-        if (ctx.spec.attributeName) {
-            if (Array.isArray(ctx.spec.attributeName)) {
-                keys = ctx.spec.attributeName;
+        if (ctx.config.attributeName) {
+            if (Array.isArray(ctx.config.attributeName)) {
+                keys = ctx.config.attributeName;
             } else {
                 keys = [
-                    ctx.spec.attributeName
+                    ctx.config.attributeName
                 ];
             }
         } else {
@@ -507,11 +507,11 @@ class RealmMatchPolicyEvaluator {
                 'realmId',
                 'realmName'
             ];
-            ctx.spec.decisionStrategy = DecisionStrategy.CONSENSUS;
+            ctx.config.decisionStrategy = DecisionStrategy.CONSENSUS;
         }
-        const attributeNameStrict = ctx.spec.attributeNameStrict ?? true;
+        const attributeNameStrict = ctx.config.attributeNameStrict ?? true;
         if (!attributeNameStrict) {
-            const resourceKeys = Object.keys(ctx.data.attributes);
+            const resourceKeys = Object.keys(ctx.input.attributes);
             const keysToAdd = [];
             for(let i = 0; i < resourceKeys.length; i++){
                 let contains = false;
@@ -531,29 +531,29 @@ class RealmMatchPolicyEvaluator {
         }
         let count = 0;
         for(let i = 0; i < keys.length; i++){
-            if (!kit.hasOwnProperty(ctx.data.attributes, keys[i])) {
+            if (!kit.hasOwnProperty(ctx.input.attributes, keys[i])) {
                 continue;
             }
             let outcome = false;
-            const attributeValue = ctx.data.attributes[keys[i]];
-            if (attributeValue === null && ctx.spec.attributeNullMatchAll) {
+            const attributeValue = ctx.input.attributes[keys[i]];
+            if (attributeValue === null && ctx.config.attributeNullMatchAll) {
                 outcome = true;
-            } else if (attributeValue === ctx.data.identity.realmId || attributeValue === ctx.data.identity.realmName) {
+            } else if (attributeValue === ctx.input.identity.realmId || attributeValue === ctx.input.identity.realmName) {
                 outcome = true;
             }
             if (outcome) {
-                if (ctx.spec.decisionStrategy === DecisionStrategy.AFFIRMATIVE) {
-                    return maybeInvertPolicyOutcome(true, ctx.spec.invert);
+                if (ctx.config.decisionStrategy === DecisionStrategy.AFFIRMATIVE) {
+                    return maybeInvertPolicyOutcome(true, ctx.config.invert);
                 }
                 count++;
             } else {
-                if (ctx.spec.decisionStrategy === DecisionStrategy.UNANIMOUS) {
-                    return maybeInvertPolicyOutcome(false, ctx.spec.invert);
+                if (ctx.config.decisionStrategy === DecisionStrategy.UNANIMOUS) {
+                    return maybeInvertPolicyOutcome(false, ctx.config.invert);
                 }
                 count--;
             }
         }
-        return maybeInvertPolicyOutcome(count > 0, ctx.spec.invert);
+        return maybeInvertPolicyOutcome(count > 0, ctx.config.invert);
     }
     constructor(){
         this.validator = new RealmMatchPolicyValidator();
@@ -619,55 +619,55 @@ function toDate(input, dateRef) {
 }
 class TimePolicyEvaluator {
     async can(ctx) {
-        return ctx.spec.type === BuiltInPolicyType.TIME;
+        return ctx.config.type === BuiltInPolicyType.TIME;
     }
-    async validateSpecification(ctx) {
-        return this.validator.run(ctx.spec);
+    async validateConfig(ctx) {
+        return this.validator.run(ctx.config);
     }
-    async validateData(ctx) {
-        return ctx.data;
+    async validateInput(ctx) {
+        return ctx.input;
     }
     async evaluate(ctx) {
         let now;
-        if (ctx.data.dateTime) {
-            now = toDate(ctx.data.dateTime);
+        if (ctx.input.dateTime) {
+            now = toDate(ctx.input.dateTime);
         } else {
             now = new Date();
         }
-        if (ctx.spec.start) {
-            const start = normalizeDate(toDate(ctx.spec.start, now), now);
+        if (ctx.config.start) {
+            const start = normalizeDate(toDate(ctx.config.start, now), now);
             if (now < start) {
-                return maybeInvertPolicyOutcome(false, ctx.spec.invert);
+                return maybeInvertPolicyOutcome(false, ctx.config.invert);
             }
         }
-        if (ctx.spec.end) {
-            const end = normalizeDate(toDate(ctx.spec.end, now), now);
+        if (ctx.config.end) {
+            const end = normalizeDate(toDate(ctx.config.end, now), now);
             if (now > end) {
-                return maybeInvertPolicyOutcome(false, ctx.spec.invert);
+                return maybeInvertPolicyOutcome(false, ctx.config.invert);
             }
         }
-        if (ctx.spec.interval) {
-            if (isIntervalForDayOfWeek(ctx.spec.interval) && ctx.spec.dayOfWeek) {
-                if (now.getDay() !== ctx.spec.dayOfWeek) {
-                    return maybeInvertPolicyOutcome(false, ctx.spec.invert);
+        if (ctx.config.interval) {
+            if (isIntervalForDayOfWeek(ctx.config.interval) && ctx.config.dayOfWeek) {
+                if (now.getDay() !== ctx.config.dayOfWeek) {
+                    return maybeInvertPolicyOutcome(false, ctx.config.invert);
                 }
             }
-            if (isIntervalForDayOfMonth(ctx.spec.interval) && ctx.spec.dayOfMonth) {
-                if (now.getDate() !== ctx.spec.dayOfMonth) {
-                    return maybeInvertPolicyOutcome(false, ctx.spec.invert);
+            if (isIntervalForDayOfMonth(ctx.config.interval) && ctx.config.dayOfMonth) {
+                if (now.getDate() !== ctx.config.dayOfMonth) {
+                    return maybeInvertPolicyOutcome(false, ctx.config.invert);
                 }
             }
-            if (isIntervalForDayOfYear(ctx.spec.interval) && ctx.spec.dayOfYear) {
+            if (isIntervalForDayOfYear(ctx.config.interval) && ctx.config.dayOfYear) {
                 const start = new Date(now.getFullYear(), 0, 0);
                 const diff = now.getTime() - start.getTime() + (start.getTimezoneOffset() - now.getTimezoneOffset()) * 60 * 1000;
                 const oneDay = 1000 * 60 * 60 * 24;
                 const dayOfYear = Math.floor(diff / oneDay);
-                if (dayOfYear !== ctx.spec.dayOfYear) {
-                    return maybeInvertPolicyOutcome(false, ctx.spec.invert);
+                if (dayOfYear !== ctx.config.dayOfYear) {
+                    return maybeInvertPolicyOutcome(false, ctx.config.invert);
                 }
             }
         }
-        return maybeInvertPolicyOutcome(true, ctx.spec.invert);
+        return maybeInvertPolicyOutcome(true, ctx.config.invert);
     }
     constructor(){
         this.validator = new TimePolicyValidator();
@@ -903,11 +903,11 @@ class PermissionChecker {
             let outcome;
             try {
                 outcome = await this.policyEngine.evaluate({
-                    data: {
-                        ...ctx.data || {},
+                    input: {
+                        ...ctx.input || {},
                         permission: entity
                     },
-                    spec: entity.policy,
+                    config: entity.policy,
                     options: {
                         include: options.policiesIncluded,
                         exclude: options.policiesExcluded