@noeldemartin/solid-utils 0.4.0-next.852c9f9e65275fc2a2e67a9750784fb43a0fd64b → 0.4.0-next.c9d36a1c12735b50a915e6ffeed60e60569706c0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noeldemartin/solid-utils",
-  "version": "0.4.0-next.852c9f9e65275fc2a2e67a9750784fb43a0fd64b",
+  "version": "0.4.0-next.c9d36a1c12735b50a915e6ffeed60e60569706c0",
   "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",
+    "@rdfjs/types": "^1.1.0",
     "core-js": "^3.12.1",
     "md5": "^2.3.0"
   },

package/src/helpers/auth.ts

@@ -80,22 +80,22 @@ 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 documentUrl = urlRoute(webId);
-    const document = await fetchSolidDocument(documentUrl, fetch);
+    const document = await fetchSolidDocument(documentUrl, options.fetch);
 
     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.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) {
-        const parentDocument = await silenced(fetchSolidDocument(parentUrl, fetch));
+        const parentDocument = await silenced(fetchSolidDocument(parentUrl, options.fetch));
 
         if (parentDocument?.isStorage()) {
             storageUrls.push(parentUrl);
@@ -110,6 +110,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 +131,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 +145,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

@@ -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.

package/src/helpers/io.ts

@@ -25,6 +25,9 @@ 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;
 
+const ANONYMOUS_PREFIX = 'anonymous://';
+const ANONYMOUS_PREFIX_LENGTH = ANONYMOUS_PREFIX.length;
+
 async function fetchRawSolidDocument(url: string, fetch: Fetch): Promise<{ body: string; headers: Headers }> {
     const options = {
         headers: { Accept: 'text/turtle' },
@@ -116,6 +119,28 @@ 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 ParsingOptions {
     baseIRI: string;
     normalizeBlankNodes: boolean;
@@ -126,6 +151,7 @@ export interface RDFGraphData {
     containsRelativeIRIs: boolean;
 }
 
+
 export async function createSolidDocument(url: string, body: string, fetch?: Fetch): Promise<SolidDocument> {
     fetch = fetch ?? window.fetch.bind(window);
 
@@ -167,7 +193,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 +208,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);

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/src/testing/faking.ts

@@ -1,38 +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 containerSlug = stringToSlug(faker.random.word());
-    const baseUrl = options.baseUrl ?? faker.internet.url();
-    const parentContainerUrl = baseUrl.endsWith('/') ? baseUrl : baseUrl + '/';
-
-    return parentContainerUrl + containerSlug + '/';
-}
-
-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;
-}