Feat/access requests

controller/package.json

@@ -24,11 +24,13 @@
         "node": ">= 20"
     },
     "dependencies": {
+        "@comunica/query-sparql": "^4.3.0",
         "@inrupt/solid-client": "^2.0.1",
         "@inrupt/solid-client-authn-browser": "^2.2.4",
         "@inrupt/vocab-common-rdf": "^1.0.5",
         "core-js": "^3.38.1",
-        "loama-common": "^1.0.0"
+        "loama-common": "^1.0.0",
+        "n3": "^1.26.0"
     },
     "devDependencies": {
         "@types/core-js": "^2.5.8",

controller/src/classes/Controller.ts → controller/src/classes/OdrlController.ts

@@ -1,24 +1,32 @@
 import { getDefaultSession } from "@inrupt/solid-client-authn-browser";
-import { BaseSubject, Index, IndexItem, Permission, ResourcePermissions, Resources, SubjectPermissions } from "../types";
+import { BaseSubject, Index, IndexItem, Permission, ResourcePermissions, Resources } from "../types";
 import { IAccessRequest, IController, IInboxConstructor, IStore, IStoreConstructor, SubjectConfig, SubjectConfigs, SubjectKey, SubjectType } from "../types/modules";
+import { type AccessRequest as AccessRequestObject } from "../types/modules";
 import { AccessRequest } from "./accessRequests/AccessRequest";
-import { InruptAccessRequest } from "./accessRequests/InruptAccessRequest";
+import { ODRLAccessRequest } from "./accessRequests/OdrlAccessRequest";
 import { Mutex } from "./utils/Mutex";
+import { ODRLAccessRequestService } from "./utils/OdrlAccessRequestService";
 
-export class Controller<T extends Record<keyof T, BaseSubject<keyof T & string>>> extends Mutex implements IController<T> {
+/**
+ * Controller which makes it calls to the backend AS through ODRL requests.
+ * Makes use of the Inrupt SDK to authenticate users.
+ */
+export class ODRLController<T extends Record<keyof T, BaseSubject<keyof T & string>>> extends Mutex implements IController<T> {
     private index: IStore<Index<T[keyof T & string]>>;
     private resources: IStore<Resources>;
     private accessRequest: AccessRequest;
     private subjectConfigs: SubjectConfigs<T>;
+    private authorizationServerURL: string;
 
     // TODO : Find a better way of constructing the controller with all the different modules
-    constructor(storeConstructor: IStoreConstructor, inboxConstructor: IInboxConstructor, subjects: SubjectConfigs<T>) {
+    constructor(storeConstructor: IStoreConstructor, inboxConstructor: IInboxConstructor, subjects: SubjectConfigs<T>, authorizationServerURL: string) {
         super();
         // There is currently no "easy" solution to get around the as IStore...
         this.index = new storeConstructor("index.json", () => ({ id: "", items: [] })) as IStore<Index<T[keyof T & string]>>;
         this.resources = new storeConstructor("resources.json", () => ({ id: "", items: [] })) as IStore<Resources>;;
-        this.accessRequest = new InruptAccessRequest(this as unknown as Controller<{}>, inboxConstructor, this.resources);
+        this.accessRequest = new ODRLAccessRequest(this as unknown as ODRLController<{}>, inboxConstructor, this.resources);
         this.subjectConfigs = subjects;
+        this.authorizationServerURL = authorizationServerURL;
     }
 
     private getSubjectConfig<K extends SubjectKey<T>>(subject: T[K]): SubjectConfig<T, T[K]> {
@@ -146,4 +154,22 @@ export class Controller<T extends Record<keyof T, BaseSubject<keyof T & string>>
         }
         return this as unknown as IController<Record<K, B>>
     }
+
+    // ! added for access requests
+    async requestAccess(permission: { action: string; resource: string; }): Promise<void> {
+        const webid = getDefaultSession().info.webId!;
+        await new ODRLAccessRequestService(this.authorizationServerURL).requestAccess(permission.resource, webid, permission.action);
+    }
+
+    async handleAccessRequest(requestId: string, status: 'accepted' | 'denied'): Promise<void> {
+        const webid = getDefaultSession().info.webId!;
+        await new ODRLAccessRequestService(this.authorizationServerURL).acceptOrDenyAccess(requestId, webid, status);
+    }
+
+    async getAccessRequests(): Promise<{
+        asRequestingParty: AccessRequestObject[];
+        asResourceOwner: AccessRequestObject[];
+    }> {
+        return new ODRLAccessRequestService(this.authorizationServerURL).retrieveAccessRequests(getDefaultSession().info.webId!);
+    }
 }

controller/src/classes/accessRequests/InruptAccessRequest.ts → controller/src/classes/accessRequests/OdrlAccessRequest.ts

@@ -4,7 +4,7 @@ import { Resources } from "@/types";
 import { getDefaultSession } from "@inrupt/solid-client-authn-browser";
 import { deleteFile } from "@inrupt/solid-client";
 
-export class InruptAccessRequest extends AccessRequest implements IAccessRequest {
+export class ODRLAccessRequest extends AccessRequest implements IAccessRequest {
     constructor(controller: IController<{}>, inboxConstructor: IInboxConstructor, resourcesStore: IStore<Resources>) {
         super(controller, inboxConstructor, resourcesStore)
     }

controller/src/classes/index.ts

@@ -1,5 +1,5 @@
-export * from './permissionManager/inrupt';
+export * from './permissionManager/odrl';
 export * from './stores/InruptStore';
 export * from './stores/BaseStore';
 export * from './subjectResolvers';
-export * from './Controller';
+export * from './OdrlController';

controller/src/classes/permissionManager/inrupt/GroupManager.ts → controller/src/classes/permissionManager/odrl/GroupManager.ts

@@ -1,12 +1,12 @@
 import { Access, AccessModes, getGroupAccessAll, getResourceInfoWithAcl } from "@inrupt/solid-client";
 import { BaseSubject, IndexItem, Permission } from "../../../types";
 import { IPermissionManager, SubjectKey } from "../../../types/modules";
-import { InruptPermissionManager } from "./InruptPermissionManager";
+import { ODRLPermissionManager } from "./OdrlPermissionManager";
 import { getDefaultSession } from "@inrupt/solid-client-authn-browser";
 import { setAgentAccess } from "@inrupt/solid-client/universal";
 import { cacheBustedSessionFetch } from "../../../util";
 
-export class GroupManager<T extends Record<keyof T, BaseSubject<keyof T & string>>> extends InruptPermissionManager<T> implements IPermissionManager<T> {
+export class GroupManager<T extends Record<keyof T, BaseSubject<keyof T & string>>> extends ODRLPermissionManager<T> implements IPermissionManager<T> {
     // This is a replacement for https://github.com/inrupt/solid-client-js/blob/eb8e86f61458ec76fa2244f7b38b7d7983bbd810/src/access/wac.ts#L262 because it is not exposed in the inrupt library
     private async getGroupAccessAll(resource: string): Promise<Record<string, Access> | null> {
         const session = getDefaultSession();

controller/src/classes/permissionManager/inrupt/InruptPermissionManager.ts → controller/src/classes/permissionManager/odrl/OdrlPermissionManager.ts

@@ -2,9 +2,9 @@ import { Access, AccessModes, getSolidDataset, getThingAll } from "@inrupt/solid
 import { SubjectPermissions, BaseSubject, IndexItem, Permission, ResourcePermissions } from "../../../types";
 import { SubjectKey, TargetSubjects } from "../../../types/modules";
 import { getDefaultSession } from "@inrupt/solid-client-authn-browser";
-import { ODRL } from "../../../classes/utils/PolicyParser";
-import { PolicyInterpreter } from "../../../classes/utils/PolicyInterpreter";
-import { PolicyService } from "../../../classes/utils/PolicyService";
+import { ODRL } from "../../utils/PolicyParser";
+import { PolicyInterpreter } from "../../utils/PolicyInterpreter";
+import { ODRLPolicyService } from "../../utils/OdrlPolicyService";
 import { Store } from 'n3';
 
 const ACCESS_MODES_TO_PERMISSION_MAPPING: Record<keyof (AccessModes & Access), Permission> = {
@@ -16,12 +16,13 @@ const ACCESS_MODES_TO_PERMISSION_MAPPING: Record<keyof (AccessModes & Access), P
     controlWrite: Permission.Control,
 }
 
-/**
- * A permission manager implementation using the inrupt sdk to actually update the ACL
- * The "Inrupt" prefix is to indicate the usage of the inrupt sdk
- * This permission manager can be used without the the InruptStore
-*/
-export abstract class InruptPermissionManager<T extends Record<keyof T, BaseSubject<keyof T & string>>> {
+export abstract class ODRLPermissionManager<T extends Record<keyof T, BaseSubject<keyof T & string>>> {
+
+    protected readonly authorizationServerURL: string;
+
+    constructor(authorizationServerURL: string) {
+        this.authorizationServerURL = authorizationServerURL;
+    }
 
     protected AccessModesToPermissions(accessModes: AccessModes | Access): Permission[] {
         const permissions = new Set<Permission>();
@@ -84,7 +85,7 @@ export abstract class InruptPermissionManager<T extends Record<keyof T, BaseSubj
      * TODO: split in subject
      */
     public async getTargetPermissionsForUser(assignerId: string, assigneeId: string, targetId: string): Promise<Permission[]> {
-        const store: Store = await new PolicyService().fetchPolicies(assignerId);
+        const store: Store = await new ODRLPolicyService(this.authorizationServerURL).fetchPolicies(assignerId);
         const target: TargetSubjects = new PolicyInterpreter().permissionsForOneResource(targetId, store);
 
         // If there are no private permissions, or no private permissions for the assignee, return the public ones (or nothing if they don't exist)
@@ -105,7 +106,7 @@ export abstract class InruptPermissionManager<T extends Record<keyof T, BaseSubj
         }
 
         // Retrieve our policies
-        const store = await new PolicyService().fetchPolicies(webId);
+        const store = await new ODRLPolicyService(this.authorizationServerURL).fetchPolicies(webId);
 
         // Get detailed info about the target
         const interpreter = new PolicyInterpreter();
@@ -164,7 +165,7 @@ export abstract class InruptPermissionManager<T extends Record<keyof T, BaseSubj
             throw new Error("User not logged in");
         }
 
-        const store = await new PolicyService().fetchPolicies(webId);
+        const store = await new ODRLPolicyService(this.authorizationServerURL).fetchPolicies(webId);
 
         // Collect target urls
         const targetUrls = Array.from(new Set(store.getQuads(null, ODRL('target'), null, null).map(q => q.object.id)));

controller/src/classes/permissionManager/inrupt/PublicManager.ts → controller/src/classes/permissionManager/odrl/PublicManager.ts

@@ -1,17 +1,17 @@
-import { PolicyService } from "../../../classes/utils/PolicyService";
+import { ODRLPolicyService } from "../../utils/OdrlPolicyService";
 import { BaseSubject, IndexItem, Permission } from "../../../types";
 import { IPermissionManager, SubjectKey } from "../../../types/modules";
-import { InruptPermissionManager } from "./InruptPermissionManager";
+import { ODRLPermissionManager } from "./OdrlPermissionManager";
 
-export class PublicManager<T extends Record<keyof T, BaseSubject<keyof T & string>>> extends InruptPermissionManager<T> implements IPermissionManager<T> {
+export class PublicManager<T extends Record<keyof T, BaseSubject<keyof T & string>>> extends ODRLPermissionManager<T> implements IPermissionManager<T> {
 
     //. NOTE: Currently, it doesn't do any recursive permission setting on containers
     async createPermissions<K extends SubjectKey<T>>(resource: string, subject: T[K], permissions: Permission[]): Promise<void> {
-        await new PolicyService().insertActionRule(resource, permissions)
+        await new ODRLPolicyService(this.authorizationServerURL).insertActionRule(resource, permissions)
     }
 
     async deletePermissions<K extends SubjectKey<T>>(resource: string, subject: T[K], permissions: Permission[]) {
-        await new PolicyService().deleteActionRule(resource, permissions)
+        await new ODRLPolicyService(this.authorizationServerURL).deleteActionRule(resource, permissions)
 
     }
 

controller/src/classes/permissionManager/inrupt/WebIdManager.ts → controller/src/classes/permissionManager/odrl/WebIdManager.ts

@@ -1,17 +1,17 @@
 import { BaseSubject, IndexItem, Permission } from "../../../types";
 import { IPermissionManager, SubjectKey } from "../../../types/modules";
-import { InruptPermissionManager } from "./InruptPermissionManager";
-import { PolicyService } from "../../utils/PolicyService";
+import { ODRLPermissionManager } from "./OdrlPermissionManager";
+import { ODRLPolicyService } from "../../utils/OdrlPolicyService";
 
-export class WebIdManager<T extends Record<keyof T, BaseSubject<keyof T & string>>> extends InruptPermissionManager<T> implements IPermissionManager<T> {
+export class WebIdManager<T extends Record<keyof T, BaseSubject<keyof T & string>>> extends ODRLPermissionManager<T> implements IPermissionManager<T> {
 
     // Create an action for this resource and this subject with the given permissions
     async createPermissions<K extends SubjectKey<T>>(resource: string, subject: T[K], permissions: Permission[]): Promise<void> {
-        await new PolicyService().insertActionRule(resource, permissions, subject.selector!.url);
+        await new ODRLPolicyService(this.authorizationServerURL).insertActionRule(resource, permissions, subject.selector!.url);
     }
 
     async deletePermissions<K extends SubjectKey<T>>(resource: string, subject: T[K], permissions: Permission[]) {
-        await new PolicyService().deleteActionRule(resource, permissions, subject.selector!.url)
+        await new ODRLPolicyService(this.authorizationServerURL).deleteActionRule(resource, permissions, subject.selector!.url)
     }
 
     async editPermissions<K extends SubjectKey<T>>(resource: string, item: IndexItem, subject: T[K], permissions: Permission[]) {

controller/src/classes/permissionManager/inrupt/index.ts → controller/src/classes/permissionManager/odrl/index.ts

@@ -1,4 +1,4 @@
 export * from './GroupManager';
-export * from './InruptPermissionManager';
+export * from './OdrlPermissionManager';
 export * from './PublicManager';
 export * from './WebIdManager';