@noeldemartin/solid-utils 0.1.1-next.2c9924cd927c0b708aef3ff4426982469f3b86fd → 0.1.1-next.43e8854d84ad29f71c5320cc51f7018a09430819

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@noeldemartin/solid-utils",
-  "version": "0.1.1-next.2c9924cd927c0b708aef3ff4426982469f3b86fd",
+  "version": "0.1.1-next.43e8854d84ad29f71c5320cc51f7018a09430819",
   "description": "My JavaScript utilities for Solid",
   "main": "dist/noeldemartin-solid-utils.cjs.js",
   "module": "dist/noeldemartin-solid-utils.esm.js",
+  "browser": "dist/noeldemartin-solid-utils.umd.js",
   "types": "dist/noeldemartin-solid-utils.d.ts",
   "scripts": {
     "build": "rm dist -rf && npm run build:js && npm run build:types",
@@ -29,13 +30,12 @@
   "homepage": "https://github.com/noeldemartin/solid-utils",
   "dependencies": {
     "@babel/runtime": "^7.14.0",
-    "@noeldemartin/utils": "^0.2.1-next.9dca1131badcdf7e51828a07ba72e4a428503066",
+    "@noeldemartin/solid-utils-external": "^0.1.0",
+    "@noeldemartin/utils": "0.2.1-next.6b17f2fc333f9389f0f4ebca96f962cd2172ee26",
     "@types/rdf-js": "^4.0.1",
     "core-js": "^3.12.1",
     "jest-diff": "^26.6.2",
-    "jsonld": "^5.2.0",
-    "md5": "^2.3.0",
-    "n3": "^1.10.0"
+    "md5": "^2.3.0"
   },
   "devDependencies": {
     "@babel/core": "^7.14.3",
@@ -45,7 +45,7 @@
     "@babel/preset-typescript": "^7.13.0",
     "@microsoft/api-extractor": "^7.15.2",
     "@noeldemartin/eslint-config-typescript": "^0.1.0-next.e83e5d37837b9845675534ab9d3745820b1326b4",
-    "@noeldemartin/scripts": "^0.1.1-next.40031a27875d800f17a8b8e7899e8304a16256c3",
+    "@noeldemartin/scripts": "^0.1.1-next.7c3f1d44c5b0fe2a75160df634ca8cae4486d378",
     "@rollup/plugin-alias": "^3.1.2",
     "@rollup/plugin-babel": "^5.3.0",
     "@rollup/plugin-commonjs": "^19.0.0",
@@ -54,9 +54,7 @@
     "@types/chai": "^4.2.18",
     "@types/jest": "^26.0.23",
     "@types/jest-diff": "^24.3.0",
-    "@types/jsonld": "^1.5.6",
     "@types/md5": "^2.3.0",
-    "@types/n3": "^1.8.0",
     "babel-plugin-transform-remove-imports": "^1.5.4",
     "eslint": "^7.26.0",
     "jest": "^26.6.3",

package/src/errors/UnsupportedAuthorizationProtocolError.ts

@@ -0,0 +1,16 @@
+import { JSError } from '@noeldemartin/utils';
+import type { JSErrorOptions } from '@noeldemartin/utils';
+
+export default class UnsupportedAuthorizationProtocolError extends JSError {
+
+    public readonly url: string;
+    public readonly protocol: string;
+
+    constructor(url: string, protocol: string, options?: JSErrorOptions) {
+        super(`The resource at ${url} is using an unsupported authorization protocol (${protocol})`, options);
+
+        this.url = url;
+        this.protocol = protocol;
+    }
+
+}

package/src/errors/index.ts

@@ -2,4 +2,5 @@ export { default as MalformedSolidDocumentError, SolidDocumentFormat } from './M
 export { default as NetworkRequestError } from './NetworkRequestError';
 export { default as NotFoundError } from './NotFoundError';
 export { default as UnauthorizedError } from './UnauthorizedError';
-export { default as UnsuccessfulRequestError } from './NetworkRequestError';
+export { default as UnsuccessfulNetworkRequestError } from './UnsuccessfulNetworkRequestError';
+export { default as UnsupportedAuthorizationProtocolError } from './UnsupportedAuthorizationProtocolError';

package/src/helpers/auth.ts

@@ -26,10 +26,16 @@ async function fetchExtendedUserProfile(webIdDocument: SolidDocument, fetch?: Fe
 }> {
     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 addReferencedDocumentUrls = (document: SolidDocument) => {
+        document
+            .statements(undefined, 'foaf:isPrimaryTopicOf')
+            .map(quad => quad.object.value)
+            .forEach(profileDocumentUrl => documents[profileDocumentUrl] = documents[profileDocumentUrl] ?? null);
+        document
+            .statements(undefined, 'foaf:primaryTopic')
+            .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) {

package/src/helpers/io.ts

@@ -1,10 +1,15 @@
 import md5 from 'md5';
+import {
+    TurtleParser,
+    TurtleWriter,
+    createBlankNode,
+    createQuad,
+    jsonLDFromRDF,
+    jsonLDToRDF,
+} from '@noeldemartin/solid-utils-external';
 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 type { Quad } from 'rdf-js';
-import type { Term as N3Term } from 'n3';
+import type { JsonLdDocument, Term } from '@noeldemartin/solid-utils-external';
 
 import SolidDocument from '@/models/SolidDocument';
 
@@ -84,25 +89,25 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
 
         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,
+            const terms: Record<string, Term> = {
+                subject: quad.subject as Term,
+                object: quad.object as Term,
             };
 
             for (const [termName, termValue] of Object.entries(terms)) {
                 if (termValue.termType !== 'BlankNode' || termValue.value !== originalId)
                     continue;
 
-                terms[termName] = new N3BlankNode(normalizedId);
+                terms[termName] = createBlankNode(normalizedId) as Term;
             }
 
             arrayReplace(
                 normalizedQuads,
                 quad,
-                new N3Quad(
-                    terms.subject as N3Term,
-                    quad.predicate as N3Term,
-                    terms.object as N3Term,
+                createQuad(
+                    terms.subject as Term,
+                    quad.predicate as Term,
+                    terms.object as Term,
                 ),
             );
         }
@@ -112,10 +117,15 @@ function normalizeBlankNodes(quads: Quad[]): Quad[] {
 }
 
 export interface ParsingOptions {
-    documentUrl: string;
+    baseIRI: string;
     normalizeBlankNodes: boolean;
 }
 
+export interface RDFGraphData {
+    quads: Quad[];
+    containsRelativeIRIs: boolean;
+}
+
 export async function createSolidDocument(url: string, body: string, fetch?: Fetch): Promise<SolidDocument> {
     fetch = fetch ?? window.fetch.bind(window);
 
@@ -132,7 +142,7 @@ export async function createSolidDocument(url: string, body: string, fetch?: Fet
 
 export async function fetchSolidDocument(url: string, fetch?: Fetch): Promise<SolidDocument> {
     const { body: data, headers } = await fetchRawSolidDocument(url, fetch ?? window.fetch);
-    const statements = await turtleToQuads(data, { documentUrl: url });
+    const statements = await turtleToQuads(data, { baseIRI: url });
 
     return new SolidDocument(url, statements, headers);
 }
@@ -150,14 +160,14 @@ export async function fetchSolidDocumentIfFound(url: string, fetch?: Fetch): Pro
     }
 }
 
-export async function jsonldToQuads(jsonld: JsonLD): Promise<Quad[]> {
+export async function jsonldToQuads(jsonld: JsonLD, baseIRI?: string): Promise<Quad[]> {
     if (isJsonLDGraph(jsonld)) {
-        const graphQuads = await Promise.all(jsonld['@graph'].map(jsonldToQuads));
+        const graphQuads = await Promise.all(jsonld['@graph'].map(resource => jsonldToQuads(resource, baseIRI)));
 
         return graphQuads.flat();
     }
 
-    return toRDF(jsonld as JsonLdDocument) as Promise<Quad[]>;
+    return jsonLDToRDF(jsonld as JsonLdDocument, { base: baseIRI }) as Promise<Quad[]>;
 }
 
 export function normalizeSparql(sparql: string): string {
@@ -173,8 +183,54 @@ export function normalizeSparql(sparql: string): string {
         .join(' ;\n');
 }
 
+export function parseTurtle(turtle: string, options: Partial<ParsingOptions> = {}): Promise<RDFGraphData> {
+    const parserOptions = objectWithoutEmpty({ baseIRI: options.baseIRI });
+    const parser = new TurtleParser(parserOptions);
+    const data: RDFGraphData = {
+        quads: [],
+        containsRelativeIRIs: false,
+    };
+
+    return new Promise((resolve, reject) => {
+        const resolveRelativeIRI = parser._resolveRelativeIRI;
+
+        parser._resolveRelativeIRI = (...args) => {
+            data.containsRelativeIRIs = true;
+            parser._resolveRelativeIRI = resolveRelativeIRI;
+
+            return parser._resolveRelativeIRI(...args);
+        };
+
+        parser.parse(turtle, (error, quad) => {
+            if (error) {
+                reject(
+                    new MalformedSolidDocumentError(
+                        options.baseIRI ?? null,
+                        SolidDocumentFormat.Turtle,
+                        error.message,
+                    ),
+                );
+
+                return;
+            }
+
+            if (!quad) {
+                // data.quads = options.normalizeBlankNodes
+                //     ? normalizeBlankNodes(data.quads)
+                //     : data.quads;
+
+                resolve(data);
+
+                return;
+            }
+
+            data.quads.push(quad);
+        });
+    });
+}
+
 export async function quadsToJsonLD(quads: Quad[]): Promise<JsonLDGraph> {
-    const graph = await fromRDF(quads);
+    const graph = await jsonLDFromRDF(quads);
 
     return {
         '@graph': graph as JsonLDResource[],
@@ -235,38 +291,13 @@ export function sparqlToQuadsSync(sparql: string, options: Partial<ParsingOption
 }
 
 export async function turtleToQuads(turtle: string, options: Partial<ParsingOptions> = {}): Promise<Quad[]> {
-    const parserOptions = objectWithoutEmpty({ baseIRI: options.documentUrl });
-    const parser = new TurtleParser(parserOptions);
-    const quads: Quad[] = [];
-
-    return new Promise((resolve, reject) => {
-        parser.parse(turtle, (error, quad) => {
-            if (error) {
-                reject(
-                    new MalformedSolidDocumentError(
-                        options.documentUrl ?? null,
-                        SolidDocumentFormat.Turtle,
-                        error.message,
-                    ),
-                );
-                return;
-            }
-
-            if (!quad) {
-                options.normalizeBlankNodes
-                    ? resolve(normalizeBlankNodes(quads))
-                    : resolve(quads);
+    const { quads } = await parseTurtle(turtle, options);
 
-                return;
-            }
-
-            quads.push(quad);
-        });
-    });
+    return quads;
 }
 
 export function turtleToQuadsSync(turtle: string, options: Partial<ParsingOptions> = {}): Quad[] {
-    const parserOptions = objectWithoutEmpty({ baseIRI: options.documentUrl });
+    const parserOptions = objectWithoutEmpty({ baseIRI: options.baseIRI });
     const parser = new TurtleParser(parserOptions);
 
     try {
@@ -277,7 +308,7 @@ export function turtleToQuadsSync(turtle: string, options: Partial<ParsingOption
             : quads;
     } catch (error) {
         throw new MalformedSolidDocumentError(
-            options.documentUrl ?? null,
+            options.baseIRI ?? null,
             SolidDocumentFormat.Turtle,
             (error as Error).message ?? '',
         );

package/src/helpers/jsonld.ts

@@ -1,3 +1,6 @@
+import { compactJsonLD } from '@noeldemartin/solid-utils-external';
+import type { JsonLdDocument } from '@noeldemartin/solid-utils-external';
+
 export type JsonLD = Partial<{
     '@context': Record<string, unknown>;
     '@id': string;
@@ -5,7 +8,24 @@ export type JsonLD = Partial<{
 }> & { [k: string]: unknown };
 
 export type JsonLDResource = Omit<JsonLD, '@id'> & { '@id': string };
-export type JsonLDGraph = { '@graph': JsonLDResource[] };
+export type JsonLDGraph = {
+    '@context'?: Record<string, unknown>;
+    '@graph': JsonLDResource[];
+};
+
+export async function compactJsonLDGraph(jsonld: JsonLDGraph): Promise<JsonLDGraph> {
+    const compactedJsonLD = await compactJsonLD(jsonld as JsonLdDocument, {});
+
+    if ('@graph' in compactedJsonLD) {
+        return compactedJsonLD as JsonLDGraph;
+    }
+
+    if ('@id' in compactedJsonLD) {
+        return { '@graph': [compactedJsonLD] } as JsonLDGraph;
+    }
+
+    return { '@graph': [] };
+}
 
 export function isJsonLDGraph(jsonld: JsonLD): jsonld is JsonLDGraph {
     return '@graph' in jsonld;

package/src/helpers/wac.ts

@@ -1,5 +1,6 @@
 import { objectWithoutEmpty, requireUrlParentDirectory, urlResolve } from '@noeldemartin/utils';
 
+import UnsupportedAuthorizationProtocolError from '@/errors/UnsupportedAuthorizationProtocolError';
 import { fetchSolidDocumentIfFound } from '@/helpers/io';
 import type SolidDocument from '@/models/SolidDocument';
 import type { Fetch } from '@/helpers/io';
@@ -25,8 +26,17 @@ async function fetchEffectiveACL(
 ): Promise<SolidDocument> {
     aclResourceUrl = aclResourceUrl ?? await fetchACLResourceUrl(resourceUrl, fetch);
 
-    return await fetchSolidDocumentIfFound(aclResourceUrl ?? '', fetch)
-        ?? await fetchEffectiveACL(requireUrlParentDirectory(resourceUrl), fetch);
+    const aclDocument = await fetchSolidDocumentIfFound(aclResourceUrl ?? '', fetch);
+
+    if (!aclDocument) {
+        return fetchEffectiveACL(requireUrlParentDirectory(resourceUrl), fetch);
+    }
+
+    if (aclDocument.isACPResource()) {
+        throw new UnsupportedAuthorizationProtocolError(resourceUrl, 'ACP');
+    }
+
+    return aclDocument;
 }
 
 export async function fetchSolidDocumentACL(documentUrl: string, fetch: Fetch): Promise<{

package/src/models/SolidDocument.ts

@@ -24,6 +24,11 @@ export default class SolidDocument extends SolidStore {
         this.headers = headers;
     }
 
+    public isACPResource(): boolean {
+        return !!this.headers.get('Link')
+            ?.match(/<http:\/\/www\.w3\.org\/ns\/solid\/acp#AccessControlResource>;[^,]+rel="type"/);
+    }
+
     public isPersonalProfile(): boolean {
         return !!this.statement(
             this.url,

package/src/types/n3.d.ts

@@ -0,0 +1,9 @@
+import '@types/n3';
+
+declare module 'n3' {
+
+    interface Parser {
+        _resolveRelativeIRI(iri: string): string;
+    }
+
+}