@noeldemartin/solid-utils 0.1.1-next.9e4a01d16d6b3e9e29a5546b75e8b5d0d8a452d6 → 0.1.1-next.e69e8c7806f3429b47d509ae8c4c0b85e96126e1

package/src/helpers/identifiers.ts

@@ -0,0 +1,56 @@
+import { arr, isArray, isObject, objectDeepClone, objectWithoutEmpty, tap, urlParse, uuid } from '@noeldemartin/utils';
+import type { UrlParts } from '@noeldemartin/utils';
+import type { JsonLD, JsonLDResource } from '@/helpers';
+
+export interface SubjectParts {
+    containerUrl?: string;
+    documentName?: string;
+    resourceHash?: string;
+}
+
+function getContainerPath(parts: UrlParts): string | null {
+    if (!parts.path || !parts.path.startsWith('/'))
+        return null;
+
+    if (parts.path.match(/^\/[^/]*$/))
+        return '/';
+
+    return `/${arr(parts.path.split('/')).filter().slice(0, -1).join('/')}/`.replace('//', '/');
+}
+
+function getContainerUrl(parts: UrlParts): string | null {
+    const containerPath = getContainerPath(parts);
+
+    return parts.protocol && parts.domain
+        ? `${parts.protocol}://${parts.domain}${containerPath ?? '/'}`
+        : containerPath;
+}
+
+function __mintJsonLDIdentifiers(jsonld: JsonLD): void {
+    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 (isArray(propertyValue))
+            propertyValue.forEach(value => isObject(value) && __mintJsonLDIdentifiers(value));
+    }
+}
+
+export function mintJsonLDIdentifiers(jsonld: JsonLD): JsonLDResource {
+    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,
+    });
+}

package/src/helpers/index.ts

@@ -1,6 +1,8 @@
 export * from './auth';
+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

@@ -6,7 +6,7 @@ import type { Fetch } from '@/helpers/io';
 import type { SolidUserProfile } from '@/helpers/auth';
 
 async function mintPrivateTypeIndexUrl(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
-    fetch = fetch ?? window.fetch;
+    fetch = fetch ?? window.fetch.bind(fetch);
 
     const storageUrl = user.storageUrls[0];
     const typeIndexUrl = `${storageUrl}settings/privateTypeIndex`;
@@ -17,7 +17,7 @@ async function mintPrivateTypeIndexUrl(user: SolidUserProfile, fetch?: Fetch): P
 }
 
 export async function createPrivateTypeIndex(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
-    fetch = fetch ?? window.fetch;
+    fetch = fetch ?? window.fetch.bind(fetch);
 
     const typeIndexUrl = await mintPrivateTypeIndexUrl(user, fetch);
     const typeIndexBody = `
@@ -46,7 +46,7 @@ export async function findContainerRegistration(
 ): Promise<SolidThing | null> {
     const typeIndex = await fetchSolidDocument(typeIndexUrl, fetch);
     const containerQuad = typeIndex
-        .statements(undefined, 'rdfs:type', 'solid:TypeRegistration')
+        .statements(undefined, 'rdf:type', 'solid:TypeRegistration')
         .find(
             statement =>
                 typeIndex.contains(statement.subject.value, 'solid:forClass', childrenType) &&

package/src/helpers/io.ts

@@ -1,8 +1,8 @@
-import { arr, arrayFilter, arrayReplace,objectWithoutEmpty } from '@noeldemartin/utils';
+import md5 from 'md5';
+import { arr, arrayFilter, arrayReplace, objectWithoutEmpty, stringMatchAll, tap } from '@noeldemartin/utils';
 import { BlankNode as N3BlankNode, Quad as N3Quad, Parser as TurtleParser, Writer as TurtleWriter } from 'n3';
+import { fromRDF, toRDF } from 'jsonld';
 import type { JsonLdDocument } from 'jsonld';
-import { toRDF } from 'jsonld';
-import md5 from 'md5';
 import type { Quad } from 'rdf-js';
 import type { Term as N3Term } from 'n3';
 
@@ -13,10 +13,10 @@ import NetworkRequestError from '@/errors/NetworkRequestError';
 import NotFoundError from '@/errors/NotFoundError';
 import UnauthorizedError from '@/errors/UnauthorizedError';
 import { isJsonLDGraph } from '@/helpers/jsonld';
-import type { JsonLD } from '@/helpers/jsonld';
+import type { JsonLD, JsonLDGraph, JsonLDResource } from '@/helpers/jsonld';
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export declare type AnyFetch = (input: any, options?: any) => Promise<any>;
+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;
 
@@ -44,7 +44,10 @@ async function fetchRawSolidDocument(url: string, fetch: Fetch): Promise<{ body:
         if (error instanceof UnauthorizedError)
             throw error;
 
-        throw new NetworkRequestError(url);
+        if (error instanceof NotFoundError)
+            throw error;
+
+        throw new NetworkRequestError(url, { cause: error });
     }
 }
 
@@ -52,26 +55,23 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
     const normalizedQuads = quads.slice(0);
     const quadsIndexes: Record<string, Set<number>> = {};
     const blankNodeIds = arr(quads)
-        .flatMap((quad, index) => {
-            const ids = arrayFilter([
-                quad.object.termType === 'BlankNode' ? quad.object.value : null,
-                quad.subject.termType === 'BlankNode' ? quad.subject.value : null,
-            ]);
-
-            for (const id of ids) {
-                quadsIndexes[id] = quadsIndexes[id] ?? new Set();
-                quadsIndexes[id].add(index);
-            }
-
-            return ids;
-        })
+        .flatMap(
+            (quad, index) => tap(
+                arrayFilter([
+                    quad.object.termType === 'BlankNode' ? quad.object.value : null,
+                    quad.subject.termType === 'BlankNode' ? quad.subject.value : null,
+                ]),
+                ids => ids.forEach(id => (quadsIndexes[id] ??= new Set()).add(index)),
+            ),
+        )
         .filter()
         .unique();
 
     for (const originalId of blankNodeIds) {
+        const quadIndexes = quadsIndexes[originalId] as Set<number>;
         const normalizedId = md5(
-            arr(quadsIndexes[originalId])
-                .map(index => quads[index])
+            arr(quadIndexes)
+                .map(index => quads[index] as Quad)
                 .filter(({ subject: { termType, value } }) => termType === 'BlankNode' && value === originalId)
                 .map(
                     ({ predicate, object }) => object.termType === 'BlankNode'
@@ -82,9 +82,12 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
                 .join(),
         );
 
-        for (const index of quadsIndexes[originalId]) {
-            const quad = normalizedQuads[index];
-            const terms: Record<string, N3Term> = { subject: quad.subject as N3Term, object: quad.object as N3Term };
+        for (const index of quadIndexes) {
+            const quad = normalizedQuads[index] as Quad;
+            const terms: Record<string, N3Term> = {
+                subject: quad.subject as N3Term,
+                object: quad.object as N3Term,
+            };
 
             for (const [termName, termValue] of Object.entries(terms)) {
                 if (termValue.termType !== 'BlankNode' || termValue.value !== originalId)
@@ -93,7 +96,15 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
                 terms[termName] = new N3BlankNode(normalizedId);
             }
 
-            arrayReplace(normalizedQuads, quad, new N3Quad(terms.subject, quad.predicate as N3Term, terms.object));
+            arrayReplace(
+                normalizedQuads,
+                quad,
+                new N3Quad(
+                    terms.subject as N3Term,
+                    quad.predicate as N3Term,
+                    terms.object as N3Term,
+                ),
+            );
         }
     }
 
@@ -106,7 +117,7 @@ export interface ParsingOptions {
 }
 
 export async function createSolidDocument(url: string, body: string, fetch?: Fetch): Promise<SolidDocument> {
-    fetch = fetch ?? window.fetch;
+    fetch = fetch ?? window.fetch.bind(window);
 
     const statements = await turtleToQuads(body);
 
@@ -126,6 +137,19 @@ export async function fetchSolidDocument(url: string, fetch?: Fetch): Promise<So
     return new SolidDocument(url, statements, headers);
 }
 
+export async function fetchSolidDocumentIfFound(url: string, fetch?: Fetch): Promise<SolidDocument | null> {
+    try {
+        const document = await fetchSolidDocument(url, fetch);
+
+        return document;
+    } catch (error) {
+        if (!(error instanceof NotFoundError))
+            throw error;
+
+        return null;
+    }
+}
+
 export async function jsonldToQuads(jsonld: JsonLD): Promise<Quad[]> {
     if (isJsonLDGraph(jsonld)) {
         const graphQuads = await Promise.all(jsonld['@graph'].map(jsonldToQuads));
@@ -149,6 +173,14 @@ export function normalizeSparql(sparql: string): string {
         .join(' ;\n');
 }
 
+export async function quadsToJsonLD(quads: Quad[]): Promise<JsonLDGraph> {
+    const graph = await fromRDF(quads);
+
+    return {
+        '@graph': graph as JsonLDResource[],
+    };
+}
+
 export function quadsToTurtle(quads: Quad[]): string {
     const writer = new TurtleWriter;
 
@@ -175,7 +207,7 @@ export async function sparqlToQuads(
     sparql: string,
     options: Partial<ParsingOptions> = {},
 ): Promise<Record<string, Quad[]>> {
-    const operations = sparql.matchAll(/(\w+) DATA {([^}]+)}/g);
+    const operations = stringMatchAll<3>(sparql, /(\w+) DATA {([^}]+)}/g);
     const quads: Record<string, Quad[]> = {};
 
     await Promise.all([...operations].map(async operation => {
@@ -189,7 +221,7 @@ export async function sparqlToQuads(
 }
 
 export function sparqlToQuadsSync(sparql: string, options: Partial<ParsingOptions> = {}): Record<string, Quad[]> {
-    const operations = sparql.matchAll(/(\w+) DATA {([^}]+)}/g);
+    const operations = stringMatchAll<3>(sparql, /(\w+) DATA {([^}]+)}/g);
     const quads: Record<string, Quad[]> = {};
 
     for (const operation of operations) {
@@ -253,7 +285,7 @@ export function turtleToQuadsSync(turtle: string, options: Partial<ParsingOption
 }
 
 export async function updateSolidDocument(url: string, body: string, fetch?: Fetch): Promise<void> {
-    fetch = fetch ?? window.fetch;
+    fetch = fetch ?? window.fetch.bind(window);
 
     await fetch(url, {
         method: 'PATCH',

package/src/helpers/testing.ts

@@ -1,4 +1,4 @@
-import { Error, arrayRemove, pull } from '@noeldemartin/utils';
+import { Error, arrayRemove, pull, stringMatchAll } from '@noeldemartin/utils';
 import type { JsonLD } from '@/helpers/jsonld';
 import type { Quad, Quad_Object } from 'rdf-js';
 
@@ -32,37 +32,36 @@ function containsPatterns(value: string): boolean {
     return /\[\[(.*\]\[)?([^\]]+)\]\]/.test(value);
 }
 
-function quadValueEquals(expected: string, actual: string): boolean {
-    if (!containsPatterns(expected))
-        return expected === actual;
-
+function createPatternRegexp(expected: string): RegExp {
     const patternAliases = [];
+    const patternMatches = stringMatchAll<4, 1 | 2>(
+        expected,
+        /\[\[((.*?)\]\[)?([^\]]+)\]\]/g,
+    );
+    const patterns: string[] = [];
+    let expectedRegExp = expected;
 
-    if (!(expected in patternsRegExpsIndex)) {
-        const patternMatches = expected.matchAll(/\[\[((.*?)\]\[)?([^\]]+)\]\]/g);
-        const patterns: string[] = [];
-        let expectedRegExp = expected;
-
-        for (const patternMatch of patternMatches) {
-            if (patternMatch[2]) {
-                patternAliases.push(patternMatch[2]);
-            }
+    for (const patternMatch of patternMatches) {
+        patternMatch[2] && patternAliases.push(patternMatch[2]);
 
-            patterns.push(patternMatch[3]);
-
-            expectedRegExp = expectedRegExp.replace(patternMatch[0], `%PATTERN${patterns.length - 1}%`);
-        }
+        patterns.push(patternMatch[3]);
 
-        expectedRegExp = expectedRegExp.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+        expectedRegExp = expectedRegExp.replace(patternMatch[0], `%PATTERN${patterns.length - 1}%`);
+    }
 
-        for (const [patternIndex, pattern] of Object.entries(patterns)) {
-            expectedRegExp = expectedRegExp.replace(`%PATTERN${patternIndex}%`, builtInPatterns[pattern] ?? pattern);
-        }
+    expectedRegExp = expectedRegExp.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
 
-        patternsRegExpsIndex[expected] = new RegExp(expectedRegExp);
+    for (const [patternIndex, pattern] of Object.entries(patterns)) {
+        expectedRegExp = expectedRegExp.replace(`%PATTERN${patternIndex}%`, builtInPatterns[pattern] ?? pattern);
     }
 
-    return patternsRegExpsIndex[expected].test(actual);
+    return new RegExp(expectedRegExp);
+}
+
+function quadValueEquals(expected: string, actual: string): boolean {
+    return containsPatterns(expected)
+        ? (patternsRegExpsIndex[expected] ??= createPatternRegexp(expected)).test(actual)
+        : expected === actual;
 }
 
 function quadObjectEquals(expected: Quad_Object, actual: Quad_Object): boolean {

package/src/helpers/vocabs.ts

@@ -6,10 +6,12 @@ export interface ExpandIRIOptions {
 }
 
 const knownPrefixes: RDFContext = {
+    acl: 'http://www.w3.org/ns/auth/acl#',
     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#',
@@ -25,7 +27,7 @@ export function expandIRI(iri: string, options: Partial<ExpandIRIOptions> = {}):
 
     const [prefix, name] = iri.split(':');
 
-    if (name) {
+    if (prefix && name) {
         const expandedPrefix = knownPrefixes[prefix] ?? options.extraContext?.[prefix] ?? null;
 
         if (!expandedPrefix)

package/src/helpers/wac.ts

@@ -0,0 +1,45 @@
+import { objectWithoutEmpty, requireUrlParentDirectory, urlResolve } from '@noeldemartin/utils';
+
+import { fetchSolidDocumentIfFound } from '@/helpers/io';
+import type SolidDocument from '@/models/SolidDocument';
+import type { Fetch } from '@/helpers/io';
+
+async function fetchACLResourceUrl(resourceUrl: string, fetch: Fetch): Promise<string> {
+    fetch = fetch ?? window.fetch.bind(window);
+
+    const resourceHead = await fetch(resourceUrl, { method: 'HEAD' });
+    const linkHeader = resourceHead.headers.get('Link') ?? '';
+    const url = linkHeader.match(/<([^>]+)>;\s*rel="acl"/)?.[1] ?? null;
+
+    if (!url) {
+        throw new Error(`Could not find ACL Resource for '${resourceUrl}'`);
+    }
+
+    return urlResolve(requireUrlParentDirectory(resourceUrl), url);
+}
+
+async function fetchEffectiveACL(
+    resourceUrl: string,
+    fetch: Fetch,
+    aclResourceUrl?: string | null,
+): Promise<SolidDocument> {
+    aclResourceUrl = aclResourceUrl ?? await fetchACLResourceUrl(resourceUrl, fetch);
+
+    return await fetchSolidDocumentIfFound(aclResourceUrl ?? '', fetch)
+        ?? await fetchEffectiveACL(requireUrlParentDirectory(resourceUrl), fetch);
+}
+
+export async function fetchSolidDocumentACL(documentUrl: string, fetch: Fetch): Promise<{
+    url: string;
+    effectiveUrl: string;
+    document: SolidDocument;
+}> {
+    const url = await fetchACLResourceUrl(documentUrl, fetch);
+    const document = await fetchEffectiveACL(documentUrl, fetch, url);
+
+    return objectWithoutEmpty({
+        url,
+        effectiveUrl: document.url,
+        document,
+    });
+}

package/src/models/SolidDocument.ts

@@ -3,28 +3,24 @@ import type { Quad } from 'rdf-js';
 
 import { expandIRI } from '@/helpers/vocabs';
 
-import SolidThing from './SolidThing';
+import SolidStore from './SolidStore';
 
-export default class SolidDocument {
+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'),
         );
     }
@@ -40,34 +36,8 @@ export default class SolidDocument {
             ?? null;
     }
 
-    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 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 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, { defaultPrefix: this.url });
     }
 
     private getLatestDocumentDate(): Date | null {

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 SolidStore } from './SolidStore';
 export { default as SolidThing } from './SolidThing';

package/src/plugins/jest/matchers.ts

@@ -16,17 +16,15 @@ function formatResult(result: EqualityResult, options: FormatResultOptions) {
         ? () => [
             result.message,
             utils.matcherHint(options.hint),
+        ].join('\n\n')
+        : () => [
+            result.message,
+            utils.matcherHint(options.hint),
             [
                 `Expected: not ${utils.printExpected(options.expected)}`,
                 `Received: ${utils.printReceived(options.received)}`,
             ].join('\n'),
-        ].join('\n\n')
-        : () => {
-            return [
-                result.message,
-                utils.matcherHint(options.hint),
-            ].join('\n\n');
-        };
+        ].join('\n\n');
 
     return { pass, message };
 }