fix: Clean up storage classes

Author: joachimvh

packages/ucp/src/index.ts

@@ -9,6 +9,5 @@ export * from './policy/ODRL'
 export * from './policy/UsageControlPolicy'
 
 // util
-export * from './util/Conversion'
 export * from './util/Util'
 export * from './util/Vocabularies'

packages/ucp/src/storage/ContainerUCRulesStorage.ts

@@ -1,8 +1,6 @@
 import type { Quad } from '@rdfjs/types';
-import { Store, Writer } from 'n3';
+import { Parser, Store, Writer } from 'n3';
 import { randomUUID } from 'node:crypto';
-import path from 'node:path';
-import { storeToString, turtleStringToStore } from '../util/Conversion';
 import { extractQuadsRecursive } from '../util/Util';
 import { UCRulesStorage } from './UCRulesStorage';
 
@@ -15,16 +13,19 @@ export class ContainerUCRulesStorage implements UCRulesStorage {
     protected readonly extraDataUrl: string;
 
     /**
-     *
-     * @param containerURL The URL to an LDP container
+     * @param containerURL - The URL to an LDP container
+     * @param customFetch - Fetch function to use for requests. Default to builtin fetch.
      */
     public constructor(
       containerURL: string,
       customFetch?: (input: RequestInfo, init?: RequestInit | undefined) => Promise<Response>
     ) {
         this.containerURL = containerURL;
         this.fetch = customFetch ?? fetch;
-        this.extraDataUrl = path.posix.join(containerURL, randomUUID());
+        if (!containerURL.endsWith('/')) {
+          throw new Error(`Invalid container URL ${containerURL}: URL does not end with a slash`);
+        }
+        this.extraDataUrl = containerURL + randomUUID();
     }
 
     public async getStore(): Promise<Store> {
@@ -41,9 +42,9 @@ export class ContainerUCRulesStorage implements UCRulesStorage {
         if (rule.size === 0) {
             return;
         }
-        const ruleString = storeToString(rule);
+        const ruleString = new Writer().quadsToString(rule.getQuads(null, null, null, null));
 
-        let response = await fetch(this.extraDataUrl, {
+        let response = await this.fetch(this.extraDataUrl, {
             method: 'PATCH',
             headers: { 'content-type': 'text/n3' },
             body: `
@@ -55,15 +56,14 @@ export class ContainerUCRulesStorage implements UCRulesStorage {
                   }.`,
             });
         if (response.status >= 400) {
-            throw Error(`Could not add rule to the storage ${response.status} ${await response.text()}`);
+            throw Error(`Could not add rule to the storage: ${response.status} - ${await response.text()}`);
         }
     }
 
     public async getRule(identifier: string): Promise<Store> {
         // would be better if there was a cache <ruleID, ldp:resource>
         const allRules = await this.getStore()
-        const rule = extractQuadsRecursive(allRules, identifier);
-        return rule
+        return extractQuadsRecursive(allRules, identifier);
     }
 
     public async deleteRule(identifier: string): Promise<void> {
@@ -86,7 +86,7 @@ export class ContainerUCRulesStorage implements UCRulesStorage {
             }
             if (matches.length > 0) {
                 const response = await this.fetch(url, {
-                    method: 'PUT',
+                    method: 'PATCH',
                     headers: { 'content-type': 'text/n3' },
                     body: `
                 @prefix solid: <http://www.w3.org/ns/solid/terms#>.
@@ -122,23 +122,23 @@ export class ContainerUCRulesStorage implements UCRulesStorage {
     }
 
     protected async readLdpRDFResource(resourceURL: string): Promise<Store> {
-        const containerResponse = await this.fetch(resourceURL, { headers: { 'accept': 'text/turtle' } });
+        const response = await this.fetch(resourceURL, { headers: { 'accept': 'text/turtle' } });
 
-        if (containerResponse.status === 404) {
+        if (response.status === 404) {
             return new Store();
         }
 
-        if (containerResponse.status !== 200) {
-            throw new Error(`Unable to acces policy container ${resourceURL}: ${
-                containerResponse.status} - ${await containerResponse.text()}`);
+        if (response.status !== 200) {
+            throw new Error(`Unable to access policy resource ${resourceURL}: ${
+                response.status} - ${await response.text()}`);
         }
 
-        const contentType = containerResponse.headers.get('content-type');
+        const contentType = response.headers.get('content-type');
         // TODO: support non-turtle formats
         if (contentType !== 'text/turtle') {
             throw new Error(`Only turtle serialization is supported, received ${contentType}`);
         }
-        const text = await containerResponse.text();
-        return await turtleStringToStore(text, resourceURL);
+        const text = await response.text();
+        return new Store(new Parser({ baseIRI: resourceURL }).parse(text));
     }
 }

packages/ucp/src/storage/DirectoryUCRulesStorage.ts

@@ -1,3 +1,4 @@
+import { extractQuadsRecursive } from '../util/Util';
 import { UCRulesStorage } from "./UCRulesStorage";
 import * as path from 'path'
 import * as fs from 'fs'
@@ -20,7 +21,7 @@ export class DirectoryUCRulesStorage implements UCRulesStorage {
       protected readonly directoryPath: string,
       protected readonly baseIRI: string,
     ) {
-        this.directoryPath = path.resolve(directoryPath);
+        this.directoryPath = directoryPath;
         if (!fs.lstatSync(directoryPath).isDirectory()) {
             throw Error(`${directoryPath} does not resolve to a directory`)
         }
@@ -33,7 +34,7 @@ export class DirectoryUCRulesStorage implements UCRulesStorage {
         }
 
         const parser = new Parser({ baseIRI: this.baseIRI });
-        const files = fs.readdirSync(this.directoryPath).map(file => path.join(this.directoryPath, file))
+        const files = (await fs.promises.readdir(this.directoryPath)).map(file => path.join(this.directoryPath, file))
         for (const file of files) {
             const quads = parser.parse((await fs.promises.readFile(file)).toString());
             this.store.addQuads(quads);
@@ -49,11 +50,14 @@ export class DirectoryUCRulesStorage implements UCRulesStorage {
 
 
     public async removeData(data: Store): Promise<void> {
+        // Make sure the files have been read into memory
+        await this.getStore();
         this.store.removeQuads(data.getQuads(null, null, null, null));
     }
 
     public async getRule(identifier: string): Promise<Store> {
-        throw Error('not implemented');
+      const allRules = await this.getStore()
+      return extractQuadsRecursive(allRules, identifier);
     }
     public async deleteRule(identifier: string): Promise<void> {
         throw Error('not implemented');