@noeldemartin/solid-utils 0.1.1-next.4e968af69bdec1e90b14bf8107fad4fafd43f952 → 0.1.1-next.50cf83f3260cb09d7b2bcb58480a6696f8596d1c

package/src/helpers/auth.ts

@@ -1,11 +1,17 @@
 import { objectWithoutEmpty, silenced, urlParentDirectory, urlRoot, urlRoute } from '@noeldemartin/utils';
 
+import SolidStore from '../models/SolidStore';
+import UnauthorizedError from '../errors/UnauthorizedError';
+import type SolidDocument from '../models/SolidDocument';
+
 import { fetchSolidDocument } from './io';
 import type { Fetch } from './io';
 
 export interface SolidUserProfile {
     webId: string;
     storageUrls: string[];
+    cloaked: boolean;
+    writableProfileUrl: string | null;
     name?: string;
     avatarUrl?: string;
     oidcIssuerUrl?: string;
@@ -13,16 +19,72 @@ export interface SolidUserProfile {
     privateTypeIndexUrl?: string;
 }
 
+async function fetchExtendedUserProfile(webIdDocument: SolidDocument, fetch?: Fetch): Promise<{
+    store: SolidStore;
+    cloaked: boolean;
+    writableProfileUrl: string | null;
+}> {
+    const store = new SolidStore(webIdDocument.getQuads());
+    const documents: Record<string, SolidDocument | false | null> = { [webIdDocument.url]: webIdDocument };
+    const addReferencedDocumentUrls = (document: SolidDocument) => document
+        .statements(undefined, 'foaf:isPrimaryTopicOf')
+        .map(quad => quad.object.value)
+        .forEach(profileDocumentUrl => documents[profileDocumentUrl] = documents[profileDocumentUrl] ?? null);
+    const loadProfileDocuments = async (): Promise<void> => {
+        for (const [url, document] of Object.entries(documents)) {
+            if (document !== null) {
+                continue;
+            }
+
+            try {
+                const document = await fetchSolidDocument(url, fetch);
+
+                documents[url] = document;
+                store.addQuads(document.getQuads());
+
+                addReferencedDocumentUrls(document);
+            } catch (error) {
+                if (error instanceof UnauthorizedError) {
+                    documents[url] = false;
+
+                    continue;
+                }
+
+                throw error;
+            }
+        }
+    };
+
+    addReferencedDocumentUrls(webIdDocument);
+
+    do {
+        await loadProfileDocuments();
+    } 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,
+    };
+}
+
 async function fetchUserProfile(webId: string, fetch?: Fetch): Promise<SolidUserProfile> {
     const documentUrl = urlRoute(webId);
     const document = await fetchSolidDocument(documentUrl, fetch);
 
-    if (!document.isPersonalProfile())
-        throw new Error(`Document at ${documentUrl} is not a profile.`);
+    if (!document.isPersonalProfile() && !document.contains(webId, 'solid:oidcIssuer'))
+        throw new Error(`${webId} is not a valid webId.`);
 
-    const storageUrls = document.statements(webId, 'pim:storage').map(storage => storage.object.value);
-    const publicTypeIndex = document.statement(webId, 'solid:publicTypeIndex');
-    const privateTypeIndex = document.statement(webId, 'solid:privateTypeIndex');
+    const { store, writableProfileUrl, cloaked } = await fetchExtendedUserProfile(document, fetch);
+    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');
 
     let parentUrl = urlParentDirectory(documentUrl);
     while (parentUrl && storageUrls.length === 0) {
@@ -37,19 +99,23 @@ async function fetchUserProfile(webId: string, fetch?: Fetch): Promise<SolidUser
         parentUrl = urlParentDirectory(parentUrl);
     }
 
-    return objectWithoutEmpty({
+    return {
         webId,
         storageUrls,
-        name:
-            document.statement(webId, 'vcard:fn')?.object.value ??
-            document.statement(webId, 'foaf:name')?.object.value,
-        avatarUrl:
-            document.statement(webId, 'vcard:hasPhoto')?.object.value ??
-            document.statement(webId, 'foaf:img')?.object.value,
-        oidcIssuerUrl: document.statement(webId, 'solid:oidcIssuer')?.object.value,
-        publicTypeIndexUrl: publicTypeIndex?.object.value,
-        privateTypeIndexUrl: privateTypeIndex?.object.value,
-    });
+        cloaked,
+        writableProfileUrl,
+        ...objectWithoutEmpty({
+            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,
+            oidcIssuerUrl: store.statement(webId, 'solid:oidcIssuer')?.object.value,
+            publicTypeIndexUrl: publicTypeIndex?.object.value,
+            privateTypeIndexUrl: privateTypeIndex?.object.value,
+        }),
+    };
 }
 
 export async function fetchLoginUserProfile(loginUrl: string, fetch?: Fetch): Promise<SolidUserProfile | null> {

package/src/helpers/interop.ts

@@ -1,59 +1,95 @@
 import { uuid } from '@noeldemartin/utils';
 
 import { createSolidDocument, fetchSolidDocument, solidDocumentExists, updateSolidDocument } from '@/helpers/io';
-import type SolidThing from '@/models/SolidThing';
 import type { Fetch } from '@/helpers/io';
 import type { SolidUserProfile } from '@/helpers/auth';
 
-async function mintPrivateTypeIndexUrl(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
+type TypeIndexType = 'public' | 'private';
+
+async function mintTypeIndexUrl(user: SolidUserProfile, type: TypeIndexType, fetch?: Fetch): Promise<string> {
     fetch = fetch ?? window.fetch.bind(fetch);
 
     const storageUrl = user.storageUrls[0];
-    const typeIndexUrl = `${storageUrl}settings/privateTypeIndex`;
+    const typeIndexUrl = `${storageUrl}settings/${type}TypeIndex`;
 
     return await solidDocumentExists(typeIndexUrl, fetch)
-        ? `${storageUrl}settings/privateTypeIndex-${uuid()}`
+        ? `${storageUrl}settings/${type}TypeIndex-${uuid()}`
         : typeIndexUrl;
 }
 
-export async function createPrivateTypeIndex(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
+async function createTypeIndex(user: SolidUserProfile, type: TypeIndexType, fetch?: Fetch) {
+    if (user.writableProfileUrl === null) {
+        throw new Error('Can\'t create type index without a writable profile document');
+    }
+
     fetch = fetch ?? window.fetch.bind(fetch);
 
-    const typeIndexUrl = await mintPrivateTypeIndexUrl(user, fetch);
-    const typeIndexBody = `
-        <> a
-            <http://www.w3.org/ns/solid/terms#TypeIndex>,
-            <http://www.w3.org/ns/solid/terms#UnlistedDocument> .
-    `;
+    const typeIndexUrl = await mintTypeIndexUrl(user, type, fetch);
+    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> .
+        `;
     const profileUpdateBody = `
         INSERT DATA {
-            <${user.webId}> <http://www.w3.org/ns/solid/terms#privateTypeIndex> <${typeIndexUrl}> .
+            <${user.webId}> <http://www.w3.org/ns/solid/terms#${type}TypeIndex> <${typeIndexUrl}> .
         }
     `;
 
     await Promise.all([
         createSolidDocument(typeIndexUrl, typeIndexBody, fetch),
-        updateSolidDocument(user.webId, profileUpdateBody, fetch),
+        updateSolidDocument(user.writableProfileUrl, profileUpdateBody, fetch),
     ]);
 
+    if (type === 'public') {
+        // TODO Implement updating ACLs for the listing itself to public
+    }
+
     return typeIndexUrl;
 }
 
-export async function findContainerRegistration(
+async function findRegistrations(
     typeIndexUrl: string,
-    childrenType: string,
+    type: string | string[],
+    predicate: string,
     fetch?: Fetch,
-): Promise<SolidThing | null> {
+): Promise<string[]> {
     const typeIndex = await fetchSolidDocument(typeIndexUrl, fetch);
-    const containerQuad = typeIndex
-        .statements(undefined, 'rdfs:type', 'solid:TypeRegistration')
-        .find(
-            statement =>
-                typeIndex.contains(statement.subject.value, 'solid:forClass', childrenType) &&
-                typeIndex.contains(statement.subject.value, 'solid:instanceContainer'),
-        );
-
-    return containerQuad
-        ? typeIndex.getThing(containerQuad.subject.value) ?? null
-        : null;
+    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();
+}
+
+export async function createPublicTypeIndex(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
+    return createTypeIndex(user, 'public', fetch);
+}
+
+export async function createPrivateTypeIndex(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
+    return createTypeIndex(user, 'private', fetch);
+}
+
+export async function findContainerRegistrations(
+    typeIndexUrl: string,
+    type: string | string[],
+    fetch?: Fetch,
+): Promise<string[]> {
+    return findRegistrations(typeIndexUrl, type, 'solid:instanceContainer', fetch);
+}
+
+export async function findInstanceRegistrations(
+    typeIndexUrl: string,
+    type: string | string[],
+    fetch?: Fetch,
+): Promise<string[]> {
+    return findRegistrations(typeIndexUrl, type, 'solid:instance', fetch);
 }

package/src/helpers/vocabs.ts

@@ -10,7 +10,8 @@ const knownPrefixes: RDFContext = {
     foaf: 'http://xmlns.com/foaf/0.1/',
     pim: 'http://www.w3.org/ns/pim/space#',
     purl: 'http://purl.org/dc/terms/',
-    rdfs: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
+    rdfs: 'http://www.w3.org/2000/01/rdf-schema#',
     schema: 'https://schema.org/',
     solid: 'http://www.w3.org/ns/solid/terms#',
     vcard: 'http://www.w3.org/2006/vcard/ns#',

package/src/models/SolidDocument.ts

@@ -1,30 +1,33 @@
-import { parseDate } from '@noeldemartin/utils';
+import { arrayFilter, parseDate, stringMatch } from '@noeldemartin/utils';
 import type { Quad } from 'rdf-js';
 
 import { expandIRI } from '@/helpers/vocabs';
 
-import SolidThing from './SolidThing';
+import SolidStore from './SolidStore';
 
-export default class SolidDocument {
+export enum SolidDocumentPermission {
+    Read = 'read',
+    Write = 'write',
+    Append = 'append',
+    Control = 'control',
+}
+
+export default class SolidDocument extends SolidStore {
 
     public readonly url: string;
     public readonly headers: Headers;
-    private quads: Quad[];
 
     public constructor(url: string, quads: Quad[], headers: Headers) {
+        super(quads);
+
         this.url = url;
-        this.quads = quads;
         this.headers = headers;
     }
 
-    public isEmpty(): boolean {
-        return this.statements.length === 0;
-    }
-
     public isPersonalProfile(): boolean {
         return !!this.statement(
             this.url,
-            expandIRI('rdfs:type'),
+            expandIRI('rdf:type'),
             expandIRI('foaf:PersonalProfileDocument'),
         );
     }
@@ -33,41 +36,27 @@ export default class SolidDocument {
         return !!this.headers.get('Link')?.match(/<http:\/\/www\.w3\.org\/ns\/pim\/space#Storage>;[^,]+rel="type"/);
     }
 
-    public getLastModified(): Date | null {
-        return parseDate(this.headers.get('last-modified'))
-            ?? parseDate(this.statement(this.url, 'purl:modified')?.object.value)
-            ?? this.getLatestDocumentDate()
-            ?? null;
+    public isUserWritable(): boolean {
+        return this.getUserPermissions().includes(SolidDocumentPermission.Write);
     }
 
-    public statements(subject?: string, predicate?: string, object?: string): Quad[] {
-        return this.quads.filter(
-            statement =>
-                (!object || statement.object.value === expandIRI(object, { defaultPrefix: this.url })) &&
-                (!subject || statement.subject.value === expandIRI(subject, { defaultPrefix: this.url })) &&
-                (!predicate || statement.predicate.value === expandIRI(predicate, { defaultPrefix: this.url })),
-        );
+    public getUserPermissions(): SolidDocumentPermission[] {
+        return this.getPermissionsFromWAC('user');
     }
 
-    public statement(subject?: string, predicate?: string, object?: string): Quad | null {
-        const statement = this.quads.find(
-            statement =>
-                (!object || statement.object.value === expandIRI(object, { defaultPrefix: this.url })) &&
-                (!subject || statement.subject.value === expandIRI(subject, { defaultPrefix: this.url })) &&
-                (!predicate || statement.predicate.value === expandIRI(predicate, { defaultPrefix: this.url })),
-        );
-
-        return statement ?? null;
+    public getPublicPermissions(): SolidDocumentPermission[] {
+        return this.getPermissionsFromWAC('public');
     }
 
-    public contains(subject: string, predicate?: string, object?: string): boolean {
-        return this.statement(subject, predicate, object) !== null;
+    public getLastModified(): Date | null {
+        return parseDate(this.headers.get('last-modified'))
+            ?? parseDate(this.statement(this.url, 'purl:modified')?.object.value)
+            ?? this.getLatestDocumentDate()
+            ?? null;
     }
 
-    public getThing(subject: string): SolidThing {
-        const statements = this.statements(subject);
-
-        return new SolidThing(subject, statements);
+    protected expandIRI(iri: string): string {
+        return expandIRI(iri, { defaultPrefix: this.url });
     }
 
     private getLatestDocumentDate(): Date | null {
@@ -81,4 +70,16 @@ export default class SolidDocument {
         return dates.length > 0 ? dates.reduce((a, b) => a > b ? a : b) : null;
     }
 
+    private getPermissionsFromWAC(type: string): SolidDocumentPermission[] {
+        const wacAllow = this.headers.get('WAC-Allow') ?? '';
+        const publicModes = stringMatch<2>(wacAllow, new RegExp(`${type}="([^"]+)"`))?.[1] ?? '';
+
+        return arrayFilter([
+            publicModes.includes('read') && SolidDocumentPermission.Read,
+            publicModes.includes('write') && SolidDocumentPermission.Write,
+            publicModes.includes('append') && SolidDocumentPermission.Append,
+            publicModes.includes('control') && SolidDocumentPermission.Control,
+        ]);
+    }
+
 }

package/src/models/SolidStore.ts

@@ -0,0 +1,61 @@
+import type { Quad } from 'rdf-js';
+
+import { expandIRI } from '@/helpers/vocabs';
+
+import SolidThing from './SolidThing';
+
+export default class SolidStore {
+
+    private quads: Quad[];
+
+    public constructor(quads: Quad[] = []) {
+        this.quads = quads;
+    }
+
+    public isEmpty(): boolean {
+        return this.statements.length === 0;
+    }
+
+    public getQuads(): Quad[] {
+        return this.quads.slice(0);
+    }
+
+    public addQuads(quads: Quad[]): void {
+        this.quads.push(...quads);
+    }
+
+    public statements(subject?: string, predicate?: string, object?: 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)),
+        );
+    }
+
+    public statement(subject?: string, predicate?: string, object?: 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)),
+        );
+
+        return statement ?? null;
+    }
+
+    public contains(subject: string, predicate?: string, object?: string): boolean {
+        return this.statement(subject, predicate, object) !== null;
+    }
+
+    public getThing(subject: string): SolidThing {
+        const statements = this.statements(subject);
+
+        return new SolidThing(subject, statements);
+    }
+
+    protected expandIRI(iri: string): string {
+        return expandIRI(iri);
+    }
+
+}

package/src/models/index.ts

@@ -1,2 +1,3 @@
-export { default as SolidDocument } from './SolidDocument';
+export { default as SolidDocument, SolidDocumentPermission } from './SolidDocument';
+export { default as SolidStore } from './SolidStore';
 export { default as SolidThing } from './SolidThing';