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

package/src/errors/UnauthorizedError.ts

@@ -19,9 +19,7 @@ export default class UnauthorizedError extends JSError {
     }
 
     public get forbidden(): boolean | undefined {
-        return typeof this.responseStatus !== 'undefined'
-            ? this.responseStatus === 403
-            : undefined;
+        return typeof this.responseStatus !== 'undefined' ? this.responseStatus === 403 : undefined;
     }
 
 }

package/src/errors/UnsuccessfulNetworkRequestError.ts

@@ -1,7 +1,7 @@
 import { JSError } from '@noeldemartin/utils';
 
 function getErrorMessage(messageOrResponse: string | Response, response?: Response): string {
-    response = response ?? messageOrResponse as Response;
+    response = response ?? (messageOrResponse as Response);
 
     return typeof messageOrResponse === 'string'
         ? `${messageOrResponse} (returned ${response.status} status code)`
@@ -17,7 +17,7 @@ export default class UnsuccessfulRequestError extends JSError {
     constructor(messageOrResponse: string | Response, response?: Response) {
         super(getErrorMessage(messageOrResponse, response));
 
-        this.response = response ?? messageOrResponse as Response;
+        this.response = response ?? (messageOrResponse as Response);
     }
 
 }

package/src/helpers/auth.test.ts

@@ -0,0 +1,221 @@
+import { describe, expect, it } from 'vitest';
+
+import { FakeResponse, FakeServer } from '@noeldemartin/testing';
+
+import { MalformedSolidDocumentError } from '@noeldemartin/solid-utils/errors';
+
+import { fetchLoginUserProfile } from './auth';
+
+describe('Auth helpers', () => {
+
+    it('reads NSS profiles', async () => {
+        // Arrange
+        const server = new FakeServer();
+        const webId = 'https://alice.solidcommunity.net/profile/card#me';
+
+        server.respondOnce(
+            'https://alice.solidcommunity.net/profile/card',
+            FakeResponse.success(
+                `
+                    @prefix foaf: <http://xmlns.com/foaf/0.1/>.
+                    @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+                    @prefix pim: <http://www.w3.org/ns/pim/space#>.
+                    @prefix schema: <http://schema.org/>.
+
+                    <>
+                        a foaf:PersonalProfileDocument ;
+                        foaf:maker <#me> ;
+                        foaf:primaryTopic <#me> .
+
+                    <#me>
+                        a foaf:Person, schema:Person ;
+                        foaf:name "Alice" ;
+                        pim:preferencesFile </settings/prefs.ttl> ;
+                        pim:storage </> ;
+                        solid:oidcIssuer <https://solidcommunity.net> ;
+                        solid:privateTypeIndex </settings/privateTypeIndex.ttl> ;
+                        solid:publicTypeIndex </settings/publicTypeIndex.ttl> .
+                `,
+                { 'WAC-Allow': 'user="read control write"' },
+            ),
+        );
+
+        // Act
+        const profile = await fetchLoginUserProfile(webId, { fetch: server.fetch });
+
+        // Assert
+        expect(server.getRequests()).toHaveLength(1);
+
+        expect(profile).toEqual({
+            webId,
+            name: 'Alice',
+            cloaked: false,
+            oidcIssuerUrl: 'https://solidcommunity.net',
+            storageUrls: ['https://alice.solidcommunity.net/'],
+            privateTypeIndexUrl: 'https://alice.solidcommunity.net/settings/privateTypeIndex.ttl',
+            publicTypeIndexUrl: 'https://alice.solidcommunity.net/settings/publicTypeIndex.ttl',
+            writableProfileUrl: 'https://alice.solidcommunity.net/profile/card',
+        });
+    });
+
+    it('reads ESS profiles (public)', async () => {
+        // Arrange
+        const server = new FakeServer();
+        const webId = 'https://id.inrupt.com/alice';
+
+        // The first request returns a 303 to `${webId}?lookup`,
+        // but in order to simplify mocking requests we're assuming it doesn't.
+        server.respondOnce(
+            'https://id.inrupt.com/alice',
+            FakeResponse.success(`
+                @prefix foaf: <http://xmlns.com/foaf/0.1/>.
+                @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+                @prefix pim: <http://www.w3.org/ns/pim/space#>.
+                @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+
+                <${webId}>
+                    a foaf:Agent ;
+                    rdfs:seeAlso <https://storage.inrupt.com/storage-hash/extendedProfile> ;
+                    pim:storage <https://storage.inrupt.com/storage-hash/> ;
+                    solid:oidcIssuer <https://login.inrupt.com> ;
+                    foaf:isPrimaryTopicOf <https://storage.inrupt.com/storage-hash/extendedProfile> .
+            `),
+        );
+        server.respondOnce(
+            'https://storage.inrupt.com/storage-hash/extendedProfile',
+            new FakeResponse(undefined, undefined, 401),
+        );
+
+        // Act
+        const profile = await fetchLoginUserProfile(webId, { fetch: server.fetch });
+
+        // Assert
+        expect(server.getRequests()).toHaveLength(2);
+
+        expect(profile).toEqual({
+            webId,
+            cloaked: true,
+            oidcIssuerUrl: 'https://login.inrupt.com',
+            storageUrls: ['https://storage.inrupt.com/storage-hash/'],
+            writableProfileUrl: null,
+        });
+    });
+
+    it('reads ESS profiles (authenticated)', async () => {
+        // Arrange
+        const server = new FakeServer();
+        const webId = 'https://id.inrupt.com/alice';
+
+        // The first request returns a 303 to `${webId}?lookup`,
+        // but in order to simplify mocking requests we're assuming it doesn't.
+        server.respondOnce(
+            'https://id.inrupt.com/alice',
+            FakeResponse.success(`
+                @prefix foaf: <http://xmlns.com/foaf/0.1/>.
+                @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+                @prefix pim: <http://www.w3.org/ns/pim/space#>.
+                @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
+
+                <${webId}>
+                    a foaf:Agent ;
+                    rdfs:seeAlso <https://storage.inrupt.com/storage-hash/extendedProfile> ;
+                    pim:storage <https://storage.inrupt.com/storage-hash/> ;
+                    solid:oidcIssuer <https://login.inrupt.com> ;
+                    foaf:isPrimaryTopicOf <https://storage.inrupt.com/storage-hash/extendedProfile> .
+            `),
+        );
+        server.respondOnce(
+            'https://storage.inrupt.com/storage-hash/extendedProfile',
+            FakeResponse.success(
+                `
+                    @prefix foaf:  <http://xmlns.com/foaf/0.1/> .
+                    @prefix schema:   <http://schema.org/> .
+
+                    <${webId}>
+                        a foaf:Person, schema:Person ;
+                        foaf:name "Alice" .
+
+                    <https://storage.inrupt.com/storage-hash/extendedProfile>
+                        a foaf:Document ;
+                        foaf:maker <${webId}> ;
+                        foaf:primaryTopic  <${webId}> .
+                `,
+                { 'WAC-Allow': 'user="read control write"' },
+            ),
+        );
+
+        // Act
+        const profile = await fetchLoginUserProfile(webId, { fetch: server.fetch });
+
+        // Assert
+        expect(server.getRequests()).toHaveLength(2);
+
+        expect(profile).toEqual({
+            webId,
+            name: 'Alice',
+            cloaked: false,
+            oidcIssuerUrl: 'https://login.inrupt.com',
+            storageUrls: ['https://storage.inrupt.com/storage-hash/'],
+            writableProfileUrl: 'https://storage.inrupt.com/storage-hash/extendedProfile',
+        });
+    });
+
+    it('reads use.id profiles', async () => {
+        // Arrange
+        const server = new FakeServer();
+        const webId = 'https://use.id/alice';
+        const profileTurtle = `
+            @prefix foaf: <http://xmlns.com/foaf/0.1/>.
+            @prefix solid: <http://www.w3.org/ns/solid/terms#>.
+            @prefix pim: <http://www.w3.org/ns/pim/space#>.
+
+            <${webId}/profile>
+                a foaf:PersonalProfileDocument;
+                foaf:maker <${webId}>;
+                foaf:primaryTopic <${webId}>.
+
+            <${webId}>
+                solid:oidcIssuer <https://idp.use.id/>;
+                pim:storage <https://pods.use.id/storage-hash/>.
+        `;
+
+        // The first request returns a 303 to `${webId}/profile`,
+        // but in order to simplify mocking requests we're assuming it doesn't.
+        server.respondOnce('https://use.id/alice', FakeResponse.success(profileTurtle, { 'WAC-Allow': 'user="read"' }));
+        server.respondOnce(
+            'https://use.id/alice/profile',
+            FakeResponse.success(profileTurtle, { 'WAC-Allow': 'user="read"' }),
+        );
+
+        // Act
+        const profile = await fetchLoginUserProfile(webId, { fetch: server.fetch });
+
+        // Assert
+        expect(server.getRequests()).toHaveLength(2);
+
+        expect(profile).toEqual({
+            webId,
+            cloaked: false,
+            oidcIssuerUrl: 'https://idp.use.id/',
+            storageUrls: ['https://pods.use.id/storage-hash/'],
+            writableProfileUrl: null,
+        });
+    });
+
+    it('throws errors reading required profiles', async () => {
+        // Arrange
+        const server = new FakeServer();
+        const webId = 'https://pod.example.com/profile/card#me';
+
+        server.respondOnce('https://pod.example.com/profile/card', FakeResponse.success('invalid turtle'));
+
+        // Act
+        const fetchProfile = fetchLoginUserProfile(webId, { fetch: server.fetch, required: true });
+
+        // Assert
+        await expect(fetchProfile).rejects.toBeInstanceOf(MalformedSolidDocumentError);
+
+        expect(server.getRequests()).toHaveLength(1);
+    });
+
+});

package/src/helpers/auth.ts

@@ -19,7 +19,10 @@ export interface SolidUserProfile {
     privateTypeIndexUrl?: string;
 }
 
-async function fetchExtendedUserProfile(webIdDocument: SolidDocument, options?: FetchSolidDocumentOptions): Promise<{
+async function fetchExtendedUserProfile(
+    webIdDocument: SolidDocument,
+    options?: FetchSolidDocumentOptions,
+): Promise<{
     store: SolidStore;
     cloaked: boolean;
     writableProfileUrl: string | null;
@@ -29,12 +32,12 @@ async function fetchExtendedUserProfile(webIdDocument: SolidDocument, options?:
     const addReferencedDocumentUrls = (document: SolidDocument) => {
         document
             .statements(undefined, 'foaf:isPrimaryTopicOf')
-            .map(quad => quad.object.value)
-            .forEach(profileDocumentUrl => documents[profileDocumentUrl] = documents[profileDocumentUrl] ?? null);
+            .map((quad) => quad.object.value)
+            .forEach((profileDocumentUrl) => (documents[profileDocumentUrl] = documents[profileDocumentUrl] ?? null));
         document
             .statements(undefined, 'foaf:primaryTopic')
-            .map(quad => quad.subject.value)
-            .forEach(profileDocumentUrl => documents[profileDocumentUrl] = documents[profileDocumentUrl] ?? null);
+            .map((quad) => quad.subject.value)
+            .forEach((profileDocumentUrl) => (documents[profileDocumentUrl] = documents[profileDocumentUrl] ?? null));
     };
     const loadProfileDocuments = async (): Promise<void> => {
         for (const [url, document] of Object.entries(documents)) {
@@ -43,12 +46,12 @@ async function fetchExtendedUserProfile(webIdDocument: SolidDocument, options?:
             }
 
             try {
-                const document = await fetchSolidDocument(url, options);
+                const _document = await fetchSolidDocument(url, options);
 
-                documents[url] = document;
-                store.addQuads(document.getQuads());
+                documents[url] = _document;
+                store.addQuads(_document.getQuads());
 
-                addReferencedDocumentUrls(document);
+                addReferencedDocumentUrls(_document);
             } catch (error) {
                 if (error instanceof UnauthorizedError) {
                     documents[url] = false;
@@ -65,18 +68,16 @@ async function fetchExtendedUserProfile(webIdDocument: SolidDocument, options?:
 
     do {
         await loadProfileDocuments();
-    } while (Object.values(documents).some(document => document === null));
+    } while (Object.values(documents).some((document) => document === null));
 
     return {
         store,
-        cloaked: Object.values(documents).some(document => document === false),
-        writableProfileUrl:
-            webIdDocument.isUserWritable()
-                ? webIdDocument.url
-                : Object
-                    .values(documents)
-                    .find((document): document is SolidDocument => !!document && document.isUserWritable())
-                    ?.url ?? null,
+        cloaked: Object.values(documents).some((document) => document === false),
+        writableProfileUrl: webIdDocument.isUserWritable()
+            ? webIdDocument.url
+            : (Object.values(documents).find(
+                (document): document is SolidDocument => !!document && document.isUserWritable(),
+            )?.url ?? null),
     };
 }
 
@@ -97,7 +98,7 @@ async function fetchUserProfile(webId: string, options: FetchUserProfileOptions
     }
 
     const { store, writableProfileUrl, cloaked } = await fetchExtendedUserProfile(document, options);
-    const storageUrls = store.statements(webId, 'pim:storage').map(storage => storage.object.value);
+    const storageUrls = store.statements(webId, 'pim:storage').map((storage) => storage.object.value);
     const publicTypeIndex = store.statement(webId, 'solid:publicTypeIndex');
     const privateTypeIndex = store.statement(webId, 'solid:privateTypeIndex');
 
@@ -118,7 +119,7 @@ async function fetchUserProfile(webId: string, options: FetchUserProfileOptions
         throw new Error(`Could not find any storage for ${webId}.`);
     }
 
-    await options.onLoaded?.(new SolidStore(store.statements(webId)));
+    await options.onLoaded?.(store);
 
     return {
         webId,
@@ -126,9 +127,7 @@ async function fetchUserProfile(webId: string, options: FetchUserProfileOptions
         writableProfileUrl,
         storageUrls: arrayUnique(storageUrls) as [string, ...string[]],
         ...objectWithoutEmpty({
-            name:
-                store.statement(webId, 'vcard:fn')?.object.value ??
-                store.statement(webId, 'foaf:name')?.object.value,
+            name: store.statement(webId, 'vcard:fn')?.object.value ?? store.statement(webId, 'foaf:name')?.object.value,
             avatarUrl:
                 store.statement(webId, 'vcard:hasPhoto')?.object.value ??
                 store.statement(webId, 'foaf:img')?.object.value,
@@ -156,9 +155,11 @@ export async function fetchLoginUserProfile(
         return fetchUserProfile(loginUrl, options);
     }
 
-    const fetchProfile = silenced(url => fetchUserProfile(url, options));
+    const fetchProfile = silenced((url) => fetchUserProfile(url, options));
 
-    return await fetchProfile(loginUrl)
-        ?? await fetchProfile(loginUrl.replace(/\/$/, '').concat('/profile/card#me'))
-        ?? await fetchProfile(urlRoot(loginUrl).concat('/profile/card#me'));
+    return (
+        (await fetchProfile(loginUrl)) ??
+        (await fetchProfile(loginUrl.replace(/\/$/, '').concat('/profile/card#me'))) ??
+        (await fetchProfile(urlRoot(loginUrl).concat('/profile/card#me')))
+    );
 }

package/src/helpers/identifiers.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from 'vitest';
+
+import { mintJsonLDIdentifiers } from '@noeldemartin/solid-utils/helpers';
+import { parseResourceSubject } from '@noeldemartin/solid-utils/helpers/identifiers';
+import type { JsonLD } from '@noeldemartin/solid-utils/helpers';
+
+describe('Identifiers helpers', () => {
+
+    it('mints JsonLD identifiers', () => {
+        // Arrange
+        const jsonld = {
+            '@context': { '@vocab': 'https://schema.org/' },
+            '@type': 'Recipe',
+            'name': 'Ramen',
+            'ingredients': ['Broth', 'Noodles'],
+            'instructions': [
+                {
+                    '@type': 'HowToStep',
+                    'text': 'Boil Noodles',
+                },
+                {
+                    '@type': 'HowToStep',
+                    'text': 'Dip them into the broth',
+                },
+            ],
+            'http://purl.org/dc/terms/created': {
+                '@type': 'http://www.w3.org/2001/XMLSchema#dateTime',
+                '@value': '1997-07-21T23:42:00.000Z',
+            },
+        };
+
+        // Act
+        const jsonldWithIds = mintJsonLDIdentifiers(jsonld);
+
+        // Assert
+        expect(jsonldWithIds['@id']).not.toBeUndefined();
+
+        const createdAt = jsonldWithIds['http://purl.org/dc/terms/created'] as Record<string, unknown>;
+        expect(createdAt['@id']).toBeUndefined();
+
+        const instructions = jsonldWithIds['instructions'] as [JsonLD, JsonLD];
+        expect(instructions[0]['@id']).not.toBeUndefined();
+        expect(instructions[1]['@id']).not.toBeUndefined();
+    });
+
+    it('parses subjects', () => {
+        expect(parseResourceSubject('https://my-pod.com/profile/card#me')).toEqual({
+            containerUrl: 'https://my-pod.com/profile/',
+            documentName: 'card',
+            resourceHash: 'me',
+        });
+        expect(parseResourceSubject('https://my-pod.com/about')).toEqual({
+            containerUrl: 'https://my-pod.com/',
+            documentName: 'about',
+        });
+        expect(parseResourceSubject('/profile/card#me')).toEqual({
+            containerUrl: '/profile/',
+            documentName: 'card',
+            resourceHash: 'me',
+        });
+        expect(parseResourceSubject('/about#sections')).toEqual({
+            containerUrl: '/',
+            documentName: 'about',
+            resourceHash: 'sections',
+        });
+        expect(parseResourceSubject('about#sections')).toEqual({
+            documentName: 'about',
+            resourceHash: 'sections',
+        });
+        expect(parseResourceSubject('about')).toEqual({
+            documentName: 'about',
+        });
+        expect(parseResourceSubject('')).toEqual({});
+    });
+
+});

package/src/helpers/identifiers.ts

@@ -1,6 +1,6 @@
 import { arr, isArray, isObject, objectDeepClone, objectWithoutEmpty, tap, urlParse, uuid } from '@noeldemartin/utils';
 import type { UrlParts } from '@noeldemartin/utils';
-import type { JsonLD, JsonLDResource } from '@/helpers';
+import type { JsonLD, JsonLDResource } from '@noeldemartin/solid-utils/helpers';
 
 export interface SubjectParts {
     containerUrl?: string;
@@ -9,11 +9,9 @@ export interface SubjectParts {
 }
 
 function getContainerPath(parts: UrlParts): string | null {
-    if (!parts.path || !parts.path.startsWith('/'))
-        return null;
+    if (!parts.path || !parts.path.startsWith('/')) return null;
 
-    if (parts.path.match(/^\/[^/]*$/))
-        return '/';
+    if (parts.path.match(/^\/[^/]*$/)) return '/';
 
     return `/${arr(parts.path.split('/')).filter().slice(0, -1).join('/')}/`.replace('//', '/');
 }
@@ -27,30 +25,29 @@ function getContainerUrl(parts: UrlParts): string | null {
 }
 
 function __mintJsonLDIdentifiers(jsonld: JsonLD): void {
-    if (!('@type' in jsonld) || '@value' in jsonld)
-        return;
+    if (!('@type' in jsonld) || '@value' in jsonld) return;
 
     jsonld['@id'] = jsonld['@id'] ?? uuid();
 
     for (const propertyValue of Object.values(jsonld)) {
-        if (isObject(propertyValue))
-            __mintJsonLDIdentifiers(propertyValue);
+        if (isObject(propertyValue)) __mintJsonLDIdentifiers(propertyValue);
 
-        if (isArray(propertyValue))
-            propertyValue.forEach(value => isObject(value) && __mintJsonLDIdentifiers(value));
+        if (isArray(propertyValue)) propertyValue.forEach((value) => isObject(value) && __mintJsonLDIdentifiers(value));
     }
 }
 
 export function mintJsonLDIdentifiers(jsonld: JsonLD): JsonLDResource {
-    return tap(objectDeepClone(jsonld) as JsonLDResource, clone => __mintJsonLDIdentifiers(clone));
+    return tap(objectDeepClone(jsonld) as JsonLDResource, (clone) => __mintJsonLDIdentifiers(clone));
 }
 
 export function parseResourceSubject(subject: string): SubjectParts {
     const parts = urlParse(subject);
 
-    return !parts ? {} : objectWithoutEmpty({
-        containerUrl: getContainerUrl(parts),
-        documentName: parts.path ? parts.path.split('/').pop() : null,
-        resourceHash: parts.fragment,
-    });
+    return !parts
+        ? {}
+        : objectWithoutEmpty({
+            containerUrl: getContainerUrl(parts),
+            documentName: parts.path ? parts.path.split('/').pop() : null,
+            resourceHash: parts.fragment,
+        });
 }

package/src/helpers/index.ts

@@ -3,6 +3,5 @@ export * from './identifiers';
 export * from './interop';
 export * from './io';
 export * from './jsonld';
-export * from './testing';
 export * from './vocabs';
 export * from './wac';

package/src/helpers/interop.ts

@@ -1,8 +1,13 @@
 import { uuid } from '@noeldemartin/utils';
 
-import { createSolidDocument, fetchSolidDocument, solidDocumentExists, updateSolidDocument } from '@/helpers/io';
-import type { Fetch } from '@/helpers/io';
-import type { SolidUserProfile } from '@/helpers/auth';
+import {
+    createSolidDocument,
+    fetchSolidDocument,
+    solidDocumentExists,
+    updateSolidDocument,
+} from '@noeldemartin/solid-utils/helpers/io';
+import type { Fetch } from '@noeldemartin/solid-utils/helpers/io';
+import type { SolidUserProfile } from '@noeldemartin/solid-utils/helpers/auth';
 
 type TypeIndexType = 'public' | 'private';
 
@@ -12,7 +17,7 @@ async function mintTypeIndexUrl(user: SolidUserProfile, type: TypeIndexType, fet
     const storageUrl = user.storageUrls[0];
     const typeIndexUrl = `${storageUrl}settings/${type}TypeIndex`;
 
-    return await solidDocumentExists(typeIndexUrl, { fetch })
+    return (await solidDocumentExists(typeIndexUrl, { fetch }))
         ? `${storageUrl}settings/${type}TypeIndex-${uuid()}`
         : typeIndexUrl;
 }
@@ -25,9 +30,10 @@ async function createTypeIndex(user: SolidUserProfile, type: TypeIndexType, fetc
     fetch = fetch ?? window.fetch.bind(fetch);
 
     const typeIndexUrl = await mintTypeIndexUrl(user, type, fetch);
-    const typeIndexBody = type === 'public'
-        ? '<> a <http://www.w3.org/ns/solid/terms#TypeIndex> .'
-        : `
+    const typeIndexBody =
+        type === 'public'
+            ? '<> a <http://www.w3.org/ns/solid/terms#TypeIndex> .'
+            : `
             <> a
                 <http://www.w3.org/ns/solid/terms#TypeIndex>,
                 <http://www.w3.org/ns/solid/terms#UnlistedDocument> .
@@ -60,15 +66,16 @@ async function findRegistrations(
     const typeIndex = await fetchSolidDocument(typeIndexUrl, { fetch });
     const types = Array.isArray(type) ? type : [type];
 
-    return types.map(
-        type => typeIndex
-            .statements(undefined, 'rdf:type', 'solid:TypeRegistration')
-            .filter(statement => typeIndex.contains(statement.subject.value, 'solid:forClass', type))
-            .map(statement => typeIndex.statements(statement.subject.value, predicate))
-            .flat()
-            .map(statement => statement.object.value)
-            .filter(url => !!url),
-    ).flat();
+    return types
+        .map((_type) =>
+            typeIndex
+                .statements(undefined, 'rdf:type', 'solid:TypeRegistration')
+                .filter((statement) => typeIndex.contains(statement.subject.value, 'solid:forClass', _type))
+                .map((statement) => typeIndex.statements(statement.subject.value, predicate))
+                .flat()
+                .map((statement) => statement.object.value)
+                .filter((url) => !!url))
+        .flat();
 }
 
 /**