@noeldemartin/solid-utils 0.5.0 → 0.6.0-next.508449b33de64b0bcade86b642c9793381434231

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,4 @@
+export * from './errors';
+export * from './helpers';
+export * from './models';
+export * from './types';

package/src/models/SolidDocument.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from 'vitest';
+
+import SolidDocument from '@noeldemartin/solid-utils/models/SolidDocument';
+import { turtleToQuadsSync } from '@noeldemartin/solid-utils/helpers';
+
+describe('SolidDocument', () => {
+
+    it('Identifies storage documents', () => {
+        const hasStorageHeader = (link: string) => {
+            const document = new SolidDocument('', [], new Headers({ Link: link }));
+
+            return document.isStorage();
+        };
+
+        /* eslint-disable max-len */
+        expect(hasStorageHeader('')).toBe(false);
+        expect(hasStorageHeader('<http://www.w3.org/ns/pim/space#Storage>; rel="type"')).toBe(true);
+        expect(hasStorageHeader('<http://www.w3.org/ns/pim/space#Storage>; rel="something-else"; rel="type"')).toBe(
+            true,
+        );
+        expect(
+            hasStorageHeader(
+                '<http://www.w3.org/ns/pim/space#Storage>; rel="something-else", <http://example.com>; rel="type"',
+            ),
+        ).toBe(false);
+        /* eslint-enable max-len */
+    });
+
+    it('Parses last modified from header', () => {
+        const document = new SolidDocument('', [], new Headers({ 'Last-Modified': 'Fri, 03 Sept 2021 16:09:12 GMT' }));
+
+        expect(document.getLastModified()).toEqual(new Date(1630685352000));
+    });
+
+    it('Parses last modified from document purl:modified', () => {
+        const document = new SolidDocument(
+            'https://pod.example.org/my-document',
+            turtleToQuadsSync(
+                `
+                <./fallback>
+                    <http://purl.org/dc/terms/modified>
+                    "2021-09-03T16:23:25.000Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
+
+                <>
+                    <http://purl.org/dc/terms/modified>
+                    "2021-09-03T16:09:12.000Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
+            `,
+                { baseIRI: 'https://pod.example.org/my-document' },
+            ),
+            new Headers({ 'Last-Modified': 'invalid date' }),
+        );
+
+        expect(document.getLastModified()).toEqual(new Date(1630685352000));
+    });
+
+    it('Parses last modified from any purl date', () => {
+        const document = new SolidDocument(
+            'https://pod.example.org/my-document',
+            turtleToQuadsSync(
+                `
+                <./fallback-one>
+                    <http://purl.org/dc/terms/modified>
+                    "2021-05-03T16:09:12.000Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
+
+                <./fallback-two>
+                    <http://purl.org/dc/terms/created>
+                    "2021-09-03T16:09:12.000Z"^^<http://www.w3.org/2001/XMLSchema#dateTime> .
+            `,
+                { baseIRI: 'https://pod.example.org/my-document' },
+            ),
+            new Headers({ 'Last-Modified': 'invalid date' }),
+        );
+
+        expect(document.getLastModified()).toEqual(new Date(1630685352000));
+    });
+
+});

package/src/models/SolidDocument.ts

@@ -1,7 +1,7 @@
 import { arrayFilter, parseDate, stringMatch } from '@noeldemartin/utils';
-import type { Quad } from 'rdf-js';
+import type { Quad } from '@rdfjs/types';
 
-import { expandIRI } from '@/helpers/vocabs';
+import { expandIRI } from '@noeldemartin/solid-utils/helpers/vocabs';
 
 import SolidStore from './SolidStore';
 
@@ -25,16 +25,13 @@ export default class SolidDocument extends SolidStore {
     }
 
     public isACPResource(): boolean {
-        return !!this.headers.get('Link')
+        return !!this.headers
+            .get('Link')
             ?.match(/<http:\/\/www\.w3\.org\/ns\/solid\/acp#AccessControlResource>;[^,]+rel="type"/);
     }
 
     public isPersonalProfile(): boolean {
-        return !!this.statement(
-            this.url,
-            expandIRI('rdf:type'),
-            expandIRI('foaf:PersonalProfileDocument'),
-        );
+        return !!this.statement(this.url, expandIRI('rdf:type'), expandIRI('foaf:PersonalProfileDocument'));
     }
 
     public isStorage(): boolean {
@@ -54,10 +51,12 @@ export default class SolidDocument extends SolidStore {
     }
 
     public getLastModified(): Date | null {
-        return parseDate(this.headers.get('last-modified'))
-            ?? parseDate(this.statement(this.url, 'purl:modified')?.object.value)
-            ?? this.getLatestDocumentDate()
-            ?? null;
+        return (
+            parseDate(this.headers.get('last-modified')) ??
+            parseDate(this.statement(this.url, 'purl:modified')?.object.value) ??
+            this.getLatestDocumentDate() ??
+            null
+        );
     }
 
     protected expandIRI(iri: string): string {
@@ -65,14 +64,11 @@ export default class SolidDocument extends SolidStore {
     }
 
     private getLatestDocumentDate(): Date | null {
-        const dates = [
-            ...this.statements(undefined, 'purl:modified'),
-            ...this.statements(undefined, 'purl:created'),
-        ]
-            .map(statement => parseDate(statement.object.value))
+        const dates = [...this.statements(undefined, 'purl:modified'), ...this.statements(undefined, 'purl:created')]
+            .map((statement) => parseDate(statement.object.value))
             .filter((date): date is Date => date !== null);
 
-        return dates.length > 0 ? dates.reduce((a, b) => a > b ? a : b) : null;
+        return dates.length > 0 ? dates.reduce((a, b) => (a > b ? a : b)) : null;
     }
 
     private getPermissionsFromWAC(type: string): SolidDocumentPermission[] {

package/src/models/SolidStore.ts

@@ -1,9 +1,11 @@
-import type { Quad } from 'rdf-js';
+import type { BlankNode, Literal, NamedNode, Quad, Variable } from '@rdfjs/types';
 
-import { expandIRI } from '@/helpers/vocabs';
+import { expandIRI } from '@noeldemartin/solid-utils/helpers/vocabs';
 
 import SolidThing from './SolidThing';
 
+export type Term = NamedNode | Literal | BlankNode | Quad | Variable;
+
 export default class SolidStore {
 
     private quads: Quad[];
@@ -24,21 +26,21 @@ export default class SolidStore {
         this.quads.push(...quads);
     }
 
-    public statements(subject?: string, predicate?: string, object?: string): Quad[] {
+    public statements(subject?: Term | string, predicate?: Term | string, object?: Term | string): Quad[] {
         return this.quads.filter(
-            statement =>
-                (!object || statement.object.value === this.expandIRI(object)) &&
-                (!subject || statement.subject.value === this.expandIRI(subject)) &&
-                (!predicate || statement.predicate.value === this.expandIRI(predicate)),
+            (statement) =>
+                (!object || this.termMatches(statement.object, object)) &&
+                (!subject || this.termMatches(statement.subject, subject)) &&
+                (!predicate || this.termMatches(statement.predicate, predicate)),
         );
     }
 
-    public statement(subject?: string, predicate?: string, object?: string): Quad | null {
+    public statement(subject?: Term | string, predicate?: Term | string, object?: Term | string): Quad | null {
         const statement = this.quads.find(
-            statement =>
-                (!object || statement.object.value === this.expandIRI(object)) &&
-                (!subject || statement.subject.value === this.expandIRI(subject)) &&
-                (!predicate || statement.predicate.value === this.expandIRI(predicate)),
+            (_statement) =>
+                (!object || this.termMatches(_statement.object, object)) &&
+                (!subject || this.termMatches(_statement.subject, subject)) &&
+                (!predicate || this.termMatches(_statement.predicate, predicate)),
         );
 
         return statement ?? null;
@@ -58,4 +60,12 @@ export default class SolidStore {
         return expandIRI(iri);
     }
 
+    protected termMatches(term: Term, value: Term | string): boolean {
+        if (typeof value === 'string') {
+            return this.expandIRI(value) === term.value;
+        }
+
+        return term.termType === term.termType && term.value === value.value;
+    }
+
 }

package/src/models/SolidThing.ts

@@ -1,6 +1,6 @@
-import type { Quad } from 'rdf-js';
+import type { Quad } from '@rdfjs/types';
 
-import { expandIRI } from '@/helpers/vocabs';
+import { expandIRI } from '@noeldemartin/solid-utils/helpers/vocabs';
 
 export default class SolidThing {
 
@@ -13,15 +13,13 @@ export default class SolidThing {
     }
 
     public value(property: string): string | undefined {
-        return this.quads
-            .find(quad => quad.predicate.value === expandIRI(property))
-            ?.object.value;
+        return this.quads.find((quad) => quad.predicate.value === expandIRI(property))?.object.value;
     }
 
     public values(property: string): string[] {
         return this.quads
-            .filter(quad => quad.predicate.value === expandIRI(property))
-            .map(quad => quad.object.value);
+            .filter((quad) => quad.predicate.value === expandIRI(property))
+            .map((quad) => quad.object.value);
     }
 
 }