@noeldemartin/solid-utils 0.4.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noeldemartin/solid-utils",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "My JavaScript utilities for Solid",
   "main": "dist/noeldemartin-solid-utils.cjs.js",
   "module": "dist/noeldemartin-solid-utils.esm.js",
@@ -31,10 +31,9 @@
   "homepage": "https://github.com/noeldemartin/solid-utils",
   "dependencies": {
     "@babel/runtime": "^7.14.0",
-    "@noeldemartin/faker": "^7.6.0",
     "@noeldemartin/solid-utils-external": "^0.1.1",
-    "@noeldemartin/utils": "^0.5.1",
-    "@types/rdf-js": "^4.0.1",
+    "@noeldemartin/utils": "^0.6.0",
+    "@rdfjs/types": "^1.1.0",
     "core-js": "^3.12.1",
     "md5": "^2.3.0"
   },

package/src/helpers/auth.ts

@@ -5,7 +5,7 @@ import UnauthorizedError from '../errors/UnauthorizedError';
 import type SolidDocument from '../models/SolidDocument';
 
 import { fetchSolidDocument } from './io';
-import type { Fetch } from './io';
+import type { Fetch, FetchSolidDocumentOptions } from './io';
 
 export interface SolidUserProfile {
     webId: string;
@@ -19,7 +19,7 @@ export interface SolidUserProfile {
     privateTypeIndexUrl?: string;
 }
 
-async function fetchExtendedUserProfile(webIdDocument: SolidDocument, fetch?: Fetch): Promise<{
+async function fetchExtendedUserProfile(webIdDocument: SolidDocument, options?: FetchSolidDocumentOptions): Promise<{
     store: SolidStore;
     cloaked: boolean;
     writableProfileUrl: string | null;
@@ -43,7 +43,7 @@ async function fetchExtendedUserProfile(webIdDocument: SolidDocument, fetch?: Fe
             }
 
             try {
-                const document = await fetchSolidDocument(url, fetch);
+                const document = await fetchSolidDocument(url, options);
 
                 documents[url] = document;
                 store.addQuads(document.getQuads());
@@ -80,22 +80,30 @@ async function fetchExtendedUserProfile(webIdDocument: SolidDocument, fetch?: Fe
     };
 }
 
-async function fetchUserProfile(webId: string, fetch?: Fetch): Promise<SolidUserProfile> {
+async function fetchUserProfile(webId: string, options: FetchUserProfileOptions = {}): Promise<SolidUserProfile> {
+    const requestOptions: FetchSolidDocumentOptions = {
+        fetch: options.fetch,
+
+        // Needed for CSS v7.1.3.
+        // See https://github.com/CommunitySolidServer/CommunitySolidServer/issues/1972
+        cache: 'no-store',
+    };
+
     const documentUrl = urlRoute(webId);
-    const document = await fetchSolidDocument(documentUrl, fetch);
+    const document = await fetchSolidDocument(documentUrl, requestOptions);
 
     if (!document.isPersonalProfile() && !document.contains(webId, 'solid:oidcIssuer')) {
         throw new Error(`${webId} is not a valid webId.`);
     }
 
-    const { store, writableProfileUrl, cloaked } = await fetchExtendedUserProfile(document, fetch);
+    const { store, writableProfileUrl, cloaked } = await fetchExtendedUserProfile(document, options);
     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) {
-        const parentDocument = await silenced(fetchSolidDocument(parentUrl, fetch));
+        const parentDocument = await silenced(fetchSolidDocument(parentUrl, requestOptions));
 
         if (parentDocument?.isStorage()) {
             storageUrls.push(parentUrl);
@@ -110,6 +118,8 @@ async function fetchUserProfile(webId: string, fetch?: Fetch): Promise<SolidUser
         throw new Error(`Could not find any storage for ${webId}.`);
     }
 
+    await options.onLoaded?.(new SolidStore(store.statements(webId)));
+
     return {
         webId,
         cloaked,
@@ -129,9 +139,13 @@ async function fetchUserProfile(webId: string, fetch?: Fetch): Promise<SolidUser
     };
 }
 
-export interface FetchLoginUserProfileOptions {
-    required?: boolean;
+export interface FetchUserProfileOptions {
     fetch?: Fetch;
+    onLoaded?(store: SolidStore): Promise<unknown> | unknown;
+}
+
+export interface FetchLoginUserProfileOptions extends FetchUserProfileOptions {
+    required?: boolean;
 }
 
 export async function fetchLoginUserProfile(
@@ -139,10 +153,10 @@ export async function fetchLoginUserProfile(
     options: FetchLoginUserProfileOptions = {},
 ): Promise<SolidUserProfile | null> {
     if (options.required) {
-        return fetchUserProfile(loginUrl, options.fetch);
+        return fetchUserProfile(loginUrl, options);
     }
 
-    const fetchProfile = silenced(url => fetchUserProfile(url, options.fetch));
+    const fetchProfile = silenced(url => fetchUserProfile(url, options));
 
     return await fetchProfile(loginUrl)
         ?? await fetchProfile(loginUrl.replace(/\/$/, '').concat('/profile/card#me'))

package/src/helpers/interop.ts

@@ -12,7 +12,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;
 }
@@ -38,10 +38,8 @@ async function createTypeIndex(user: SolidUserProfile, type: TypeIndexType, fetc
         }
     `;
 
-    await Promise.all([
-        createSolidDocument(typeIndexUrl, typeIndexBody, fetch),
-        updateSolidDocument(user.writableProfileUrl, profileUpdateBody, fetch),
-    ]);
+    await createSolidDocument(typeIndexUrl, typeIndexBody, fetch);
+    await updateSolidDocument(user.writableProfileUrl, profileUpdateBody, fetch);
 
     if (type === 'public') {
         // TODO This is currently implemented in soukai-solid.
@@ -59,7 +57,7 @@ async function findRegistrations(
     predicate: string,
     fetch?: Fetch,
 ): Promise<string[]> {
-    const typeIndex = await fetchSolidDocument(typeIndexUrl, fetch);
+    const typeIndex = await fetchSolidDocument(typeIndexUrl, { fetch });
     const types = Array.isArray(type) ? type : [type];
 
     return types.map(

package/src/helpers/io.ts

@@ -25,13 +25,24 @@ export declare type AnyFetch = (input: any, options?: any) => Promise<Response>;
 export declare type TypedFetch = (input: RequestInfo, options?: RequestInit) => Promise<Response>;
 export declare type Fetch = TypedFetch | AnyFetch;
 
-async function fetchRawSolidDocument(url: string, fetch: Fetch): Promise<{ body: string; headers: Headers }> {
-    const options = {
+const ANONYMOUS_PREFIX = 'anonymous://';
+const ANONYMOUS_PREFIX_LENGTH = ANONYMOUS_PREFIX.length;
+
+async function fetchRawSolidDocument(
+    url: string,
+    options?: FetchSolidDocumentOptions,
+): Promise<{ body: string; headers: Headers }> {
+    const requestOptions: RequestInit = {
         headers: { Accept: 'text/turtle' },
     };
 
+    if (options?.cache) {
+        requestOptions.cache = options.cache;
+    }
+
     try {
-        const response = await fetch(url, options);
+        const fetch = options?.fetch ?? window.fetch;
+        const response = await fetch(url, requestOptions);
 
         if (response.status === 404)
             throw new NotFoundError(url);
@@ -116,6 +127,33 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
     return normalizedQuads;
 }
 
+function normalizeQuads(quads: Quad[]): string {
+    return quads.map(quad => '    ' + quadToTurtle(quad)).sort().join('\n');
+}
+
+function preprocessSubjects(jsonld: JsonLD): void {
+    if (!jsonld['@id']?.startsWith('#')) {
+        return;
+    }
+
+    jsonld['@id'] = ANONYMOUS_PREFIX + jsonld['@id'];
+}
+
+function postprocessSubjects(quads: Quad[]): void {
+    for (const quad of quads) {
+        if (!quad.subject.value.startsWith(ANONYMOUS_PREFIX)) {
+            continue;
+        }
+
+        quad.subject.value = quad.subject.value.slice(ANONYMOUS_PREFIX_LENGTH);
+    }
+}
+
+export interface FetchSolidDocumentOptions {
+    fetch?: Fetch;
+    cache?: RequestCache;
+}
+
 export interface ParsingOptions {
     baseIRI: string;
     normalizeBlankNodes: boolean;
@@ -140,16 +178,19 @@ export async function createSolidDocument(url: string, body: string, fetch?: Fet
     return new SolidDocument(url, statements, new Headers({}));
 }
 
-export async function fetchSolidDocument(url: string, fetch?: Fetch): Promise<SolidDocument> {
-    const { body: data, headers } = await fetchRawSolidDocument(url, fetch ?? window.fetch);
+export async function fetchSolidDocument(url: string, options?: FetchSolidDocumentOptions): Promise<SolidDocument> {
+    const { body: data, headers } = await fetchRawSolidDocument(url, options);
     const statements = await turtleToQuads(data, { baseIRI: url });
 
     return new SolidDocument(url, statements, headers);
 }
 
-export async function fetchSolidDocumentIfFound(url: string, fetch?: Fetch): Promise<SolidDocument | null> {
+export async function fetchSolidDocumentIfFound(
+    url: string,
+    options?: FetchSolidDocumentOptions,
+): Promise<SolidDocument | null> {
     try {
-        const document = await fetchSolidDocument(url, fetch);
+        const document = await fetchSolidDocument(url, options);
 
         return document;
     } catch (error) {
@@ -167,7 +208,13 @@ export async function jsonldToQuads(jsonld: JsonLD, baseIRI?: string): Promise<Q
         return graphQuads.flat();
     }
 
-    return jsonLDToRDF(jsonld as JsonLdDocument, { base: baseIRI }) as Promise<Quad[]>;
+    preprocessSubjects(jsonld);
+
+    const quads = await (jsonLDToRDF(jsonld as JsonLdDocument, { base: baseIRI }) as Promise<Quad[]>);
+
+    postprocessSubjects(quads);
+
+    return quads;
 }
 
 export function normalizeSparql(sparql: string): string {
@@ -176,13 +223,19 @@ export function normalizeSparql(sparql: string): string {
     return Object
         .entries(quads)
         .reduce((normalizedOperations, [operation, quads]) => {
-            const normalizedQuads = quads.map(quad => '    ' + quadToTurtle(quad)).sort().join('\n');
+            const normalizedQuads = normalizeQuads(quads);
 
             return normalizedOperations.concat(`${operation.toUpperCase()} DATA {\n${normalizedQuads}\n}`);
         }, [] as string[])
         .join(' ;\n');
 }
 
+export function normalizeTurtle(sparql: string): string {
+    const quads = turtleToQuadsSync(sparql);
+
+    return normalizeQuads(quads);
+}
+
 export function parseTurtle(turtle: string, options: Partial<ParsingOptions> = {}): Promise<RDFGraphData> {
     const parserOptions = objectWithoutEmpty({ baseIRI: options.baseIRI });
     const parser = new TurtleParser(parserOptions);
@@ -249,9 +302,9 @@ export function quadToTurtle(quad: Quad): string {
     return writer.quadsToString([quad]).slice(0, -1);
 }
 
-export async function solidDocumentExists(url: string, fetch?: Fetch): Promise<boolean> {
+export async function solidDocumentExists(url: string, options?: FetchSolidDocumentOptions): Promise<boolean> {
     try {
-        const document = await fetchSolidDocument(url, fetch);
+        const document = await fetchSolidDocument(url, options);
 
         return !document.isEmpty();
     } catch (error) {

package/src/helpers/vocabs.ts

@@ -8,6 +8,7 @@ export interface ExpandIRIOptions {
 const knownPrefixes: RDFContext = {
     acl: 'http://www.w3.org/ns/auth/acl#',
     foaf: 'http://xmlns.com/foaf/0.1/',
+    ldp: 'http://www.w3.org/ns/ldp#',
     pim: 'http://www.w3.org/ns/pim/space#',
     purl: 'http://purl.org/dc/terms/',
     rdf: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',

package/src/helpers/wac.ts

@@ -26,7 +26,7 @@ async function fetchEffectiveACL(
 ): Promise<SolidDocument> {
     aclResourceUrl = aclResourceUrl ?? await fetchACLResourceUrl(resourceUrl, fetch);
 
-    const aclDocument = await fetchSolidDocumentIfFound(aclResourceUrl ?? '', fetch);
+    const aclDocument = await fetchSolidDocumentIfFound(aclResourceUrl ?? '', { fetch });
 
     if (!aclDocument) {
         return fetchEffectiveACL(requireUrlParentDirectory(resourceUrl), fetch);

package/src/plugins/jest/matchers.ts

@@ -1,5 +1,5 @@
-import { normalizeSparql } from '@/helpers/io';
-import { jsonldEquals, sparqlEquals } from '@/helpers/testing';
+import { normalizeSparql, normalizeTurtle } from '@/helpers/io';
+import { jsonldEquals, sparqlEquals, turtleEquals } from '@/helpers/testing';
 import type { EqualityResult } from '@/helpers/testing';
 
 interface FormatResultOptions {
@@ -50,6 +50,16 @@ const matchers: jest.ExpectExtendMap = {
             received: normalizeSparql(received),
         });
     },
+    toEqualTurtle(received, expected) {
+        const result = turtleEquals(expected, received);
+
+        return formatResult(result, {
+            context: this,
+            hint: 'toEqualTurtle',
+            expected: normalizeTurtle(expected),
+            received: normalizeTurtle(received),
+        });
+    },
 };
 
 export default matchers;

package/src/plugins/jest/types.d.ts

@@ -5,6 +5,7 @@ declare global {
         // TODO generate automatically
         interface Matchers<R> {
             toEqualSparql(sparql: string): R;
+            toEqualTurtle(turtle: string): R;
             toEqualJsonLD(jsonld: JsonLD): Promise<R>;
         }
 

package/src/testing/index.ts

@@ -1,3 +1,2 @@
-export * from './faking';
 export * from './mocking';
 export { default as ResponseStub } from './ResponseStub';

package/.semaphore/semaphore.yml

@@ -1,26 +0,0 @@
-version: v1.0
-name: Solid Utils
-agent:
-  machine:
-    type: e1-standard-2
-    os_image: ubuntu1804
-blocks:
-  - name: CI
-    task:
-      prologue:
-        commands:
-          - checkout
-          - nvm install
-          - cache restore
-          - npm ci
-          - cache store
-      jobs:
-        - name: Linting
-          commands:
-            - npm run lint
-        - name: Tests
-          commands:
-            - npm test
-        - name: Build
-          commands:
-            - npm run build

package/src/testing/faking.ts

@@ -1,36 +0,0 @@
-import { faker } from '@noeldemartin/faker';
-import { stringToSlug } from '@noeldemartin/utils';
-
-export interface ContainerOptions {
-    baseUrl: string;
-}
-
-export interface DocumentOptions extends ContainerOptions {
-    containerUrl: string;
-    name: string;
-}
-
-export interface ResourceOptions extends DocumentOptions {
-    documentUrl: string;
-    hash: string;
-}
-
-export function fakeContainerUrl(options: Partial<ContainerOptions> = {}): string {
-    const baseUrl = options.baseUrl ?? faker.internet.url();
-
-    return baseUrl.endsWith('/') ? baseUrl : baseUrl + '/';
-}
-
-export function fakeDocumentUrl(options: Partial<DocumentOptions> = {}): string {
-    const containerUrl = options.containerUrl ?? fakeContainerUrl(options);
-    const name = options.name ?? faker.random.word();
-
-    return containerUrl + stringToSlug(name);
-}
-
-export function fakeResourceUrl(options: Partial<ResourceOptions> = {}): string {
-    const documentUrl = options.documentUrl ?? fakeDocumentUrl(options);
-    const hash = options.hash ?? 'it';
-
-    return documentUrl + '#' + hash;
-}