@noeldemartin/solid-utils 0.5.0 → 0.6.0-next.3e3ceb79b047f4ec87a416c2f920a13eda7a0df1

package/src/helpers/io.test.ts

@@ -0,0 +1,228 @@
+import { describe, expect, it } from 'vitest';
+
+import { jsonldToQuads, normalizeSparql, quadsToJsonLD, sparqlToQuadsSync, turtleToQuadsSync } from './io';
+import type { Quad } from '@rdfjs/types';
+
+describe('IO', () => {
+
+    it('parses jsonld', async () => {
+        // Arrange
+        const jsonld = {
+            '@context': { '@vocab': 'https://schema.org/' },
+            '@type': 'Movie',
+            'name': 'Spirited Away',
+        };
+
+        // Act
+        const quads = (await jsonldToQuads(jsonld)) as [Quad, Quad];
+
+        // Assert
+        expect(quads).toHaveLength(2);
+
+        expect(quads[0].subject.termType).toEqual('BlankNode');
+        expect(quads[0].predicate.termType).toEqual('NamedNode');
+        expect(quads[0].predicate.value).toEqual('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+        expect(quads[0].object.termType).toEqual('NamedNode');
+        expect(quads[0].object.value).toEqual('https://schema.org/Movie');
+
+        expect(quads[1].subject.termType).toEqual('BlankNode');
+        expect(quads[1].predicate.termType).toEqual('NamedNode');
+        expect(quads[1].predicate.value).toEqual('https://schema.org/name');
+        expect(quads[1].object.termType).toEqual('Literal');
+        expect(quads[1].object.value).toEqual('Spirited Away');
+    });
+
+    it('parses jsonld with anonymous subjects', async () => {
+        // Arrange
+        const jsonld = {
+            '@context': { '@vocab': 'https://schema.org/' },
+            '@id': '#it',
+            '@type': 'Movie',
+            'name': 'Spirited Away',
+        };
+
+        // Act
+        const quads = (await jsonldToQuads(jsonld)) as [Quad, Quad];
+
+        // Assert
+        expect(quads).toHaveLength(2);
+
+        expect(quads[0].subject.termType).toEqual('NamedNode');
+        expect(quads[0].subject.value).toEqual('#it');
+        expect(quads[0].predicate.termType).toEqual('NamedNode');
+        expect(quads[0].predicate.value).toEqual('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+        expect(quads[0].object.termType).toEqual('NamedNode');
+        expect(quads[0].object.value).toEqual('https://schema.org/Movie');
+
+        expect(quads[1].subject.termType).toEqual('NamedNode');
+        expect(quads[1].subject.value).toEqual('#it');
+        expect(quads[1].predicate.termType).toEqual('NamedNode');
+        expect(quads[1].predicate.value).toEqual('https://schema.org/name');
+        expect(quads[1].object.termType).toEqual('Literal');
+        expect(quads[1].object.value).toEqual('Spirited Away');
+    });
+
+    it('parses jsonld graphs', async () => {
+        // Arrange
+        const jsonld = {
+            '@graph': [
+                {
+                    '@context': { '@vocab': 'https://schema.org/' },
+                    '@id': 'solid://movies/spirited-away',
+                    '@type': 'Movie',
+                    'name': 'Spirited Away',
+                },
+                {
+                    '@context': { '@vocab': 'https://schema.org/' },
+                    '@id': 'solid://movies/spirited-away',
+                    '@type': 'Movie',
+                    'name': 'Spirited Away',
+                },
+            ],
+        };
+
+        // Act
+        const quads = await jsonldToQuads(jsonld);
+
+        // Assert
+        expect(quads).toHaveLength(4);
+
+        [0, 2].forEach((index) => {
+            expect(quads[index]?.subject.termType).toEqual('NamedNode');
+            expect(quads[index]?.subject.value).toEqual('solid://movies/spirited-away');
+            expect(quads[index]?.predicate.termType).toEqual('NamedNode');
+            expect(quads[index]?.predicate.value).toEqual('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+            expect(quads[index]?.object.termType).toEqual('NamedNode');
+            expect(quads[index]?.object.value).toEqual('https://schema.org/Movie');
+        });
+
+        [1, 3].forEach((index) => {
+            expect(quads[index]?.subject.termType).toEqual('NamedNode');
+            expect(quads[index]?.subject.value).toEqual('solid://movies/spirited-away');
+            expect(quads[index]?.predicate.termType).toEqual('NamedNode');
+            expect(quads[index]?.predicate.value).toEqual('https://schema.org/name');
+            expect(quads[index]?.object.termType).toEqual('Literal');
+            expect(quads[index]?.object.value).toEqual('Spirited Away');
+        });
+    });
+
+    it('normalizes sparql', () => {
+        // Arrange
+        const insertTurtle = `
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#me>
+                foaf:name "Amy" ;
+                foaf:lastName "Doe" .
+        `;
+        const deleteTurtle = `
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#me> foaf:name "John Doe" .
+        `;
+        const sparql = `
+            INSERT DATA { ${insertTurtle} } ;
+            DELETE DATA { ${deleteTurtle} }
+        `;
+
+        // Act
+        const normalized = normalizeSparql(sparql);
+
+        // Assert
+        expect(normalized).toEqual(
+            [
+                'INSERT DATA {',
+                '    <#me> <http://xmlns.com/foaf/0.1/lastName> "Doe" .',
+                '    <#me> <http://xmlns.com/foaf/0.1/name> "Amy" .',
+                '} ;',
+                'DELETE DATA {',
+                '    <#me> <http://xmlns.com/foaf/0.1/name> "John Doe" .',
+                '}',
+            ].join('\n'),
+        );
+    });
+
+    it('parses sparql', () => {
+        // Arrange
+        const insertTurtle = `
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#me> foaf:name "Amy Doe" .
+        `;
+        const deleteTurtle = `
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#me> foaf:name "John Doe" .
+        `;
+        const sparql = `
+            INSERT DATA { ${insertTurtle} } ;
+            DELETE DATA { ${deleteTurtle} }
+        `;
+
+        // Act
+        const quads = sparqlToQuadsSync(sparql);
+
+        // Assert
+        expect(Object.keys(quads)).toHaveLength(2);
+
+        expect(quads.insert).toEqual(turtleToQuadsSync(insertTurtle));
+        expect(quads.delete).toEqual(turtleToQuadsSync(deleteTurtle));
+    });
+
+    it('parses turtle synchronously', () => {
+        // Arrange
+        const turtle = `
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#me>
+                a foaf:Person ;
+                foaf:name "John Doe" .
+        `;
+
+        // Act
+        const quads = turtleToQuadsSync(turtle) as [Quad, Quad];
+
+        // Assert
+        expect(quads).toHaveLength(2);
+
+        expect(quads[0].subject.termType).toEqual('NamedNode');
+        expect(quads[0].subject.value).toEqual('#me');
+        expect(quads[0].predicate.termType).toEqual('NamedNode');
+        expect(quads[0].predicate.value).toEqual('http://www.w3.org/1999/02/22-rdf-syntax-ns#type');
+        expect(quads[0].object.termType).toEqual('NamedNode');
+        expect(quads[0].object.value).toEqual('http://xmlns.com/foaf/0.1/Person');
+
+        expect(quads[1].subject.termType).toEqual('NamedNode');
+        expect(quads[1].subject.value).toEqual('#me');
+        expect(quads[1].predicate.termType).toEqual('NamedNode');
+        expect(quads[1].predicate.value).toEqual('http://xmlns.com/foaf/0.1/name');
+        expect(quads[1].object.termType).toEqual('Literal');
+        expect(quads[1].object.value).toEqual('John Doe');
+    });
+
+    it('converts quads to jsonld', async () => {
+        // Arrange
+        const quads = turtleToQuadsSync(`
+            @prefix foaf: <http://xmlns.com/foaf/0.1/> .
+
+            <#me>
+                a foaf:Person ;
+                foaf:name "John Doe" .
+        `);
+
+        // Act
+        const jsonld = await quadsToJsonLD(quads);
+
+        // Assert
+        expect(jsonld).toEqual({
+            '@graph': [
+                {
+                    '@id': '#me',
+                    '@type': ['http://xmlns.com/foaf/0.1/Person'],
+                    'http://xmlns.com/foaf/0.1/name': [{ '@value': 'John Doe' }],
+                },
+            ],
+        });
+    });
+
+});

package/src/helpers/io.ts

@@ -1,24 +1,20 @@
+import jsonld from 'jsonld';
 import md5 from 'md5';
-import {
-    TurtleParser,
-    TurtleWriter,
-    createBlankNode,
-    createQuad,
-    jsonLDFromRDF,
-    jsonLDToRDF,
-} from '@noeldemartin/solid-utils-external';
 import { arr, arrayFilter, arrayReplace, objectWithoutEmpty, stringMatchAll, tap } from '@noeldemartin/utils';
-import type { Quad } from 'rdf-js';
-import type { JsonLdDocument, Term } from '@noeldemartin/solid-utils-external';
+import { BlankNode as N3BlankNode, Quad as N3Quad, Parser, Writer } from 'n3';
+import type { JsonLdDocument } from 'jsonld';
+import type { Quad } from '@rdfjs/types';
+import type { Term } from 'n3';
 
-import SolidDocument from '@/models/SolidDocument';
+import SolidDocument from '@noeldemartin/solid-utils/models/SolidDocument';
 
-import MalformedSolidDocumentError, { SolidDocumentFormat } from '@/errors/MalformedSolidDocumentError';
-import NetworkRequestError from '@/errors/NetworkRequestError';
-import NotFoundError from '@/errors/NotFoundError';
-import UnauthorizedError from '@/errors/UnauthorizedError';
-import { isJsonLDGraph } from '@/helpers/jsonld';
-import type { JsonLD, JsonLDGraph, JsonLDResource } from '@/helpers/jsonld';
+// eslint-disable-next-line max-len
+import MalformedSolidDocumentError, { SolidDocumentFormat } from '@noeldemartin/solid-utils/errors/MalformedSolidDocumentError';
+import NetworkRequestError from '@noeldemartin/solid-utils/errors/NetworkRequestError';
+import NotFoundError from '@noeldemartin/solid-utils/errors/NotFoundError';
+import UnauthorizedError from '@noeldemartin/solid-utils/errors/UnauthorizedError';
+import { isJsonLDGraph } from '@noeldemartin/solid-utils/helpers/jsonld';
+import type { JsonLD, JsonLDGraph, JsonLDResource } from '@noeldemartin/solid-utils/helpers/jsonld';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export declare type AnyFetch = (input: any, options?: any) => Promise<Response>;
@@ -44,11 +40,9 @@ async function fetchRawSolidDocument(
         const fetch = options?.fetch ?? window.fetch;
         const response = await fetch(url, requestOptions);
 
-        if (response.status === 404)
-            throw new NotFoundError(url);
+        if (response.status === 404) throw new NotFoundError(url);
 
-        if ([401, 403].includes(response.status))
-            throw new UnauthorizedError(url, response.status);
+        if ([401, 403].includes(response.status)) throw new UnauthorizedError(url, response.status);
 
         const body = await response.text();
 
@@ -57,11 +51,9 @@ async function fetchRawSolidDocument(
             headers: response.headers,
         };
     } catch (error) {
-        if (error instanceof UnauthorizedError)
-            throw error;
+        if (error instanceof UnauthorizedError) throw error;
 
-        if (error instanceof NotFoundError)
-            throw error;
+        if (error instanceof NotFoundError) throw error;
 
         throw new NetworkRequestError(url, { cause: error });
     }
@@ -71,15 +63,14 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
     const normalizedQuads = quads.slice(0);
     const quadsIndexes: Record<string, Set<number>> = {};
     const blankNodeIds = arr(quads)
-        .flatMap(
-            (quad, index) => tap(
+        .flatMap((quad, index) =>
+            tap(
                 arrayFilter([
                     quad.object.termType === 'BlankNode' ? quad.object.value : null,
                     quad.subject.termType === 'BlankNode' ? quad.subject.value : null,
                 ]),
-                ids => ids.forEach(id => (quadsIndexes[id] ??= new Set()).add(index)),
-            ),
-        )
+                (ids) => ids.forEach((id) => (quadsIndexes[id] ??= new Set()).add(index)),
+            ))
         .filter()
         .unique();
 
@@ -87,13 +78,10 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
         const quadIndexes = quadsIndexes[originalId] as Set<number>;
         const normalizedId = md5(
             arr(quadIndexes)
-                .map(index => quads[index] as Quad)
+                .map((index) => quads[index] as Quad)
                 .filter(({ subject: { termType, value } }) => termType === 'BlankNode' && value === originalId)
-                .map(
-                    ({ predicate, object }) => object.termType === 'BlankNode'
-                        ? predicate.value
-                        : predicate.value + object.value,
-                )
+                .map(({ predicate, object }) =>
+                    object.termType === 'BlankNode' ? predicate.value : predicate.value + object.value)
                 .sorted()
                 .join(),
         );
@@ -106,20 +94,15 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
             };
 
             for (const [termName, termValue] of Object.entries(terms)) {
-                if (termValue.termType !== 'BlankNode' || termValue.value !== originalId)
-                    continue;
+                if (termValue.termType !== 'BlankNode' || termValue.value !== originalId) continue;
 
-                terms[termName] = createBlankNode(normalizedId) as Term;
+                terms[termName] = new N3BlankNode(normalizedId) as Term;
             }
 
             arrayReplace(
                 normalizedQuads,
                 quad,
-                createQuad(
-                    terms.subject as Term,
-                    quad.predicate as Term,
-                    terms.object as Term,
-                ),
+                new N3Quad(terms.subject as Term, quad.predicate as Term, terms.object as Term),
             );
         }
     }
@@ -128,15 +111,18 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
 }
 
 function normalizeQuads(quads: Quad[]): string {
-    return quads.map(quad => '    ' + quadToTurtle(quad)).sort().join('\n');
+    return quads
+        .map((quad) => '    ' + quadToTurtle(quad))
+        .sort()
+        .join('\n');
 }
 
-function preprocessSubjects(jsonld: JsonLD): void {
-    if (!jsonld['@id']?.startsWith('#')) {
+function preprocessSubjects(json: JsonLD): void {
+    if (!json['@id']?.startsWith('#')) {
         return;
     }
 
-    jsonld['@id'] = ANONYMOUS_PREFIX + jsonld['@id'];
+    json['@id'] = ANONYMOUS_PREFIX + json['@id'];
 }
 
 function postprocessSubjects(quads: Quad[]): void {
@@ -194,23 +180,22 @@ export async function fetchSolidDocumentIfFound(
 
         return document;
     } catch (error) {
-        if (!(error instanceof NotFoundError))
-            throw error;
+        if (!(error instanceof NotFoundError)) throw error;
 
         return null;
     }
 }
 
-export async function jsonldToQuads(jsonld: JsonLD, baseIRI?: string): Promise<Quad[]> {
-    if (isJsonLDGraph(jsonld)) {
-        const graphQuads = await Promise.all(jsonld['@graph'].map(resource => jsonldToQuads(resource, baseIRI)));
+export async function jsonldToQuads(json: JsonLD, baseIRI?: string): Promise<Quad[]> {
+    if (isJsonLDGraph(json)) {
+        const graphQuads = await Promise.all(json['@graph'].map((resource) => jsonldToQuads(resource, baseIRI)));
 
         return graphQuads.flat();
     }
 
-    preprocessSubjects(jsonld);
+    preprocessSubjects(json);
 
-    const quads = await (jsonLDToRDF(jsonld as JsonLdDocument, { base: baseIRI }) as Promise<Quad[]>);
+    const quads = await (jsonld.toRDF(json as JsonLdDocument, { base: baseIRI }) as Promise<Quad[]>);
 
     postprocessSubjects(quads);
 
@@ -220,10 +205,9 @@ export async function jsonldToQuads(jsonld: JsonLD, baseIRI?: string): Promise<Q
 export function normalizeSparql(sparql: string): string {
     const quads = sparqlToQuadsSync(sparql);
 
-    return Object
-        .entries(quads)
-        .reduce((normalizedOperations, [operation, quads]) => {
-            const normalizedQuads = normalizeQuads(quads);
+    return Object.entries(quads)
+        .reduce((normalizedOperations, [operation, _quads]) => {
+            const normalizedQuads = normalizeQuads(_quads);
 
             return normalizedOperations.concat(`${operation.toUpperCase()} DATA {\n${normalizedQuads}\n}`);
         }, [] as string[])
@@ -238,7 +222,7 @@ export function normalizeTurtle(sparql: string): string {
 
 export function parseTurtle(turtle: string, options: Partial<ParsingOptions> = {}): Promise<RDFGraphData> {
     const parserOptions = objectWithoutEmpty({ baseIRI: options.baseIRI });
-    const parser = new TurtleParser(parserOptions);
+    const parser = new Parser(parserOptions);
     const data: RDFGraphData = {
         quads: [],
         containsRelativeIRIs: false,
@@ -257,11 +241,7 @@ export function parseTurtle(turtle: string, options: Partial<ParsingOptions> = {
         parser.parse(turtle, (error, quad) => {
             if (error) {
                 reject(
-                    new MalformedSolidDocumentError(
-                        options.baseIRI ?? null,
-                        SolidDocumentFormat.Turtle,
-                        error.message,
-                    ),
+                    new MalformedSolidDocumentError(options.baseIRI ?? null, SolidDocumentFormat.Turtle, error.message),
                 );
 
                 return;
@@ -283,7 +263,7 @@ export function parseTurtle(turtle: string, options: Partial<ParsingOptions> = {
 }
 
 export async function quadsToJsonLD(quads: Quad[]): Promise<JsonLDGraph> {
-    const graph = await jsonLDFromRDF(quads);
+    const graph = await jsonld.fromRDF(quads);
 
     return {
         '@graph': graph as JsonLDResource[],
@@ -291,13 +271,13 @@ export async function quadsToJsonLD(quads: Quad[]): Promise<JsonLDGraph> {
 }
 
 export function quadsToTurtle(quads: Quad[]): string {
-    const writer = new TurtleWriter;
+    const writer = new Writer();
 
     return writer.quadsToString(quads);
 }
 
 export function quadToTurtle(quad: Quad): string {
-    const writer = new TurtleWriter;
+    const writer = new Writer();
 
     return writer.quadsToString([quad]).slice(0, -1);
 }
@@ -319,12 +299,14 @@ export async function sparqlToQuads(
     const operations = stringMatchAll<3>(sparql, /(\w+) DATA {([^}]+)}/g);
     const quads: Record<string, Quad[]> = {};
 
-    await Promise.all([...operations].map(async operation => {
-        const operationName = operation[1].toLowerCase();
-        const operationBody = operation[2];
+    await Promise.all(
+        [...operations].map(async (operation) => {
+            const operationName = operation[1].toLowerCase();
+            const operationBody = operation[2];
 
-        quads[operationName] = await turtleToQuads(operationBody, options);
-    }));
+            quads[operationName] = await turtleToQuads(operationBody, options);
+        }),
+    );
 
     return quads;
 }
@@ -351,14 +333,12 @@ export async function turtleToQuads(turtle: string, options: Partial<ParsingOpti
 
 export function turtleToQuadsSync(turtle: string, options: Partial<ParsingOptions> = {}): Quad[] {
     const parserOptions = objectWithoutEmpty({ baseIRI: options.baseIRI });
-    const parser = new TurtleParser(parserOptions);
+    const parser = new Parser(parserOptions);
 
     try {
         const quads = parser.parse(turtle);
 
-        return options.normalizeBlankNodes
-            ? normalizeBlankNodes(quads)
-            : quads;
+        return options.normalizeBlankNodes ? normalizeBlankNodes(quads) : quads;
     } catch (error) {
         throw new MalformedSolidDocumentError(
             options.baseIRI ?? null,

package/src/helpers/jsonld.ts

@@ -1,5 +1,5 @@
-import { compactJsonLD } from '@noeldemartin/solid-utils-external';
-import type { JsonLdDocument } from '@noeldemartin/solid-utils-external';
+import jsonld from 'jsonld';
+import type { JsonLdDocument } from 'jsonld';
 
 export type JsonLD = Partial<{
     '@context': Record<string, unknown>;
@@ -13,8 +13,8 @@ export type JsonLDGraph = {
     '@graph': JsonLDResource[];
 };
 
-export async function compactJsonLDGraph(jsonld: JsonLDGraph): Promise<JsonLDGraph> {
-    const compactedJsonLD = await compactJsonLD(jsonld as JsonLdDocument, {});
+export async function compactJsonLDGraph(json: JsonLDGraph): Promise<JsonLDGraph> {
+    const compactedJsonLD = await jsonld.compact(json as JsonLdDocument, {});
 
     if ('@graph' in compactedJsonLD) {
         return compactedJsonLD as JsonLDGraph;
@@ -27,6 +27,6 @@ export async function compactJsonLDGraph(jsonld: JsonLDGraph): Promise<JsonLDGra
     return { '@graph': [] };
 }
 
-export function isJsonLDGraph(jsonld: JsonLD): jsonld is JsonLDGraph {
-    return '@graph' in jsonld;
+export function isJsonLDGraph(json: JsonLD): json is JsonLDGraph {
+    return '@graph' in json;
 }

package/src/helpers/vocabs.ts

@@ -23,22 +23,19 @@ export function defineIRIPrefix(name: string, value: string): void {
 }
 
 export function expandIRI(iri: string, options: Partial<ExpandIRIOptions> = {}): string {
-    if (iri.startsWith('http'))
-        return iri;
+    if (iri.startsWith('http')) return iri;
 
     const [prefix, name] = iri.split(':');
 
     if (prefix && name) {
         const expandedPrefix = knownPrefixes[prefix] ?? options.extraContext?.[prefix] ?? null;
 
-        if (!expandedPrefix)
-            throw new Error(`Can't expand IRI with unknown prefix: '${iri}'`);
+        if (!expandedPrefix) throw new Error(`Can't expand IRI with unknown prefix: '${iri}'`);
 
         return expandedPrefix + name;
     }
 
-    if (!options.defaultPrefix)
-        throw new Error(`Can't expand IRI without a default prefix: '${iri}'`);
+    if (!options.defaultPrefix) throw new Error(`Can't expand IRI without a default prefix: '${iri}'`);
 
     return options.defaultPrefix + prefix;
 }

package/src/helpers/wac.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, it } from 'vitest';
+import { FakeResponse, FakeServer } from '@noeldemartin/testing';
+
+// eslint-disable-next-line max-len
+import UnsupportedAuthorizationProtocolError from '@noeldemartin/solid-utils/errors/UnsupportedAuthorizationProtocolError';
+
+import { fetchSolidDocumentACL } from './wac';
+
+describe('WAC helpers', () => {
+
+    it('resolves relative ACL urls', async () => {
+        // Arrange
+        const server = new FakeServer();
+        const documentUrl = 'https://example.com/alice/movies/my-favorite-movie';
+
+        server.respondOnce(documentUrl, FakeResponse.success(undefined, { Link: '<my-favorite-movie.acl>;rel="acl"' }));
+        server.respondOnce(
+            `${documentUrl}.acl`,
+            FakeResponse.success(`
+                @prefix acl: <http://www.w3.org/ns/auth/acl#>.
+                @prefix foaf: <http://xmlns.com/foaf/0.1/>.
+
+                <#owner>
+                    a acl:Authorization;
+                    acl:agent <https://example.com/alice/profile/card#me>;
+                    acl:accessTo <./my-favorite-movie> ;
+                    acl:mode acl:Read, acl:Write, acl:Control .
+            `),
+        );
+
+        // Act
+        const { url, effectiveUrl, document } = await fetchSolidDocumentACL(documentUrl, server.fetch);
+
+        // Assert
+        expect(url).toEqual(`${documentUrl}.acl`);
+        expect(effectiveUrl).toEqual(url);
+        expect(document.contains(`${documentUrl}.acl#owner`, 'rdf:type', 'acl:Authorization')).toBe(true);
+
+        expect(server.getRequests()).toHaveLength(2);
+        expect(server.getRequest(documentUrl)?.method).toEqual('HEAD');
+        expect(server.getRequest(url)).not.toBeNull();
+    });
+
+    it('fails with ACP resources', async () => {
+        // Arrange
+        const server = new FakeServer();
+        const documentUrl = 'https://example.com/alice/movies/my-favorite-movie';
+
+        server.respondOnce(documentUrl, FakeResponse.success(undefined, { Link: '<my-favorite-movie.acl>;rel="acl"' }));
+        server.respondOnce(
+            `${documentUrl}.acl`,
+            FakeResponse.success(undefined, {
+                Link: '<http://www.w3.org/ns/solid/acp#AccessControlResource>; rel="type"',
+            }),
+        );
+
+        // Act
+        const promisedDocument = fetchSolidDocumentACL(documentUrl, server.fetch);
+
+        // Assert
+        await expect(promisedDocument).rejects.toBeInstanceOf(UnsupportedAuthorizationProtocolError);
+    });
+
+});

package/src/helpers/wac.ts

@@ -1,9 +1,10 @@
 import { objectWithoutEmpty, requireUrlParentDirectory, urlResolve } from '@noeldemartin/utils';
 
-import UnsupportedAuthorizationProtocolError from '@/errors/UnsupportedAuthorizationProtocolError';
-import { fetchSolidDocumentIfFound } from '@/helpers/io';
-import type SolidDocument from '@/models/SolidDocument';
-import type { Fetch } from '@/helpers/io';
+// eslint-disable-next-line max-len
+import UnsupportedAuthorizationProtocolError from '@noeldemartin/solid-utils/errors/UnsupportedAuthorizationProtocolError';
+import { fetchSolidDocumentIfFound } from '@noeldemartin/solid-utils/helpers/io';
+import type SolidDocument from '@noeldemartin/solid-utils/models/SolidDocument';
+import type { Fetch } from '@noeldemartin/solid-utils/helpers/io';
 
 async function fetchACLResourceUrl(resourceUrl: string, fetch: Fetch): Promise<string> {
     fetch = fetch ?? window.fetch.bind(window);
@@ -24,7 +25,7 @@ async function fetchEffectiveACL(
     fetch: Fetch,
     aclResourceUrl?: string | null,
 ): Promise<SolidDocument> {
-    aclResourceUrl = aclResourceUrl ?? await fetchACLResourceUrl(resourceUrl, fetch);
+    aclResourceUrl = aclResourceUrl ?? (await fetchACLResourceUrl(resourceUrl, fetch));
 
     const aclDocument = await fetchSolidDocumentIfFound(aclResourceUrl ?? '', { fetch });
 
@@ -39,7 +40,10 @@ async function fetchEffectiveACL(
     return aclDocument;
 }
 
-export async function fetchSolidDocumentACL(documentUrl: string, fetch: Fetch): Promise<{
+export async function fetchSolidDocumentACL(
+    documentUrl: string,
+    fetch: Fetch,
+): Promise<{
     url: string;
     effectiveUrl: string;
     document: SolidDocument;

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './errors';
+export * from './helpers';
+export * from './models';