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

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();
 }
 
 /**

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' }],
+                },
+            ],
+        });
+    });
+
+});