@noeldemartin/solid-utils 0.1.1 → 0.2.0

package/noeldemartin.config.js

@@ -1,7 +1,9 @@
-module.exports = {
+const { defineConfig } = require('@noeldemartin/scripts');
+
+module.exports = defineConfig({
     name: 'NoelDeMartinSolidUtils',
     declarations: [
         // 'src/plugins/cypress/types.d.ts',
         'src/plugins/jest/types.d.ts',
     ],
-};
+});

package/package.json

@@ -1,26 +1,27 @@
 {
   "name": "@noeldemartin/solid-utils",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "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",
     "build:js": "noeldemartin-build-javascript",
     "build:types": "noeldemartin-build-types",
-    "lint": "eslint src",
+    "lint": "noeldemartin-lint src",
     "publish-next": "noeldemartin-publish-next",
     "test": "jest --verbose",
     "test:coverage": "jest --coverage"
   },
-  "engines": {
-    "node": ">=14.x"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/noeldemartin/solid-utils.git"
   },
+  "engines": {
+    "node": ">=14.x"
+  },
   "author": "Noel De Martin",
   "license": "MIT",
   "bugs": {
@@ -29,12 +30,12 @@
   "homepage": "https://github.com/noeldemartin/solid-utils",
   "dependencies": {
     "@babel/runtime": "^7.14.0",
-    "@noeldemartin/utils": "^0.2.1",
+    "@noeldemartin/solid-utils-external": "^0.1.0",
+    "@noeldemartin/utils": "^0.3.0",
     "@types/rdf-js": "^4.0.1",
     "core-js": "^3.12.1",
     "jest-diff": "^26.6.2",
-    "md5": "^2.3.0",
-    "n3": "^1.10.0"
+    "md5": "^2.3.0"
   },
   "devDependencies": {
     "@babel/core": "^7.14.3",
@@ -43,8 +44,8 @@
     "@babel/preset-env": "^7.14.2",
     "@babel/preset-typescript": "^7.13.0",
     "@microsoft/api-extractor": "^7.15.2",
-    "@noeldemartin/eslint-config-typescript": "^0.1.0",
-    "@noeldemartin/scripts": "^0.1.1",
+    "@noeldemartin/eslint-config-typescript": "^0.1.1",
+    "@noeldemartin/scripts": "^0.1.2",
     "@rollup/plugin-alias": "^3.1.2",
     "@rollup/plugin-babel": "^5.3.0",
     "@rollup/plugin-commonjs": "^19.0.0",
@@ -54,7 +55,6 @@
     "@types/jest": "^26.0.23",
     "@types/jest-diff": "^24.3.0",
     "@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/MalformedSolidDocumentError.ts

@@ -1,4 +1,4 @@
-import { Error } from '@noeldemartin/utils';
+import { JSError } from '@noeldemartin/utils';
 
 function errorMessage(
     documentUrl: string | null,
@@ -14,7 +14,7 @@ export enum SolidDocumentFormat {
     Turtle = 'Turtle',
 }
 
-export default class MalformedSolidDocumentError extends Error {
+export default class MalformedSolidDocumentError extends JSError {
 
     public readonly documentUrl: string | null;
     public readonly documentFormat: SolidDocumentFormat;

package/src/errors/NetworkRequestError.ts

@@ -1,11 +1,12 @@
-import { Error } from '@noeldemartin/utils';
+import { JSError } from '@noeldemartin/utils';
+import type { JSErrorOptions } from '@noeldemartin/utils';
 
-export default class NetworkRequestError extends Error {
+export default class NetworkRequestError extends JSError {
 
     public readonly url: string;
 
-    constructor(url: string) {
-        super(`Request failed trying to fetch ${url}`);
+    constructor(url: string, options?: JSErrorOptions) {
+        super(`Request failed trying to fetch ${url}`, options);
 
         this.url = url;
     }

package/src/errors/NotFoundError.ts

@@ -1,6 +1,6 @@
-import { Error } from '@noeldemartin/utils';
+import { JSError } from '@noeldemartin/utils';
 
-export default class NotFoundError extends Error {
+export default class NotFoundError extends JSError {
 
     public readonly url: string;
 

package/src/errors/UnauthorizedError.ts

@@ -1,4 +1,4 @@
-import { Error } from '@noeldemartin/utils';
+import { JSError } from '@noeldemartin/utils';
 
 function errorMessage(url: string, responseStatus?: number): string {
     const typeInfo = responseStatus === 403 ? ' (Forbidden)' : '';
@@ -6,7 +6,7 @@ function errorMessage(url: string, responseStatus?: number): string {
     return `Unauthorized${typeInfo}: ${url}`;
 }
 
-export default class UnauthorizedError extends Error {
+export default class UnauthorizedError extends JSError {
 
     public readonly url: string;
     public readonly responseStatus?: number;

package/src/errors/UnsuccessfulNetworkRequestError.ts

@@ -0,0 +1,23 @@
+import { JSError } from '@noeldemartin/utils';
+
+function getErrorMessage(messageOrResponse: string | Response, response?: Response): string {
+    response = response ?? messageOrResponse as Response;
+
+    return typeof messageOrResponse === 'string'
+        ? `${messageOrResponse} (returned ${response.status} status code)`
+        : `Request to ${response.url} returned ${response.status} status code`;
+}
+
+export default class UnsuccessfulRequestError extends JSError {
+
+    public response: Response;
+
+    constructor(response: Response);
+    constructor(message: string, response: Response);
+    constructor(messageOrResponse: string | Response, response?: Response) {
+        super(getErrorMessage(messageOrResponse, response));
+
+        this.response = response ?? messageOrResponse as Response;
+    }
+
+}

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,3 +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 UnsuccessfulNetworkRequestError } from './UnsuccessfulNetworkRequestError';
+export { default as UnsupportedAuthorizationProtocolError } from './UnsupportedAuthorizationProtocolError';

package/src/helpers/auth.ts

@@ -1,4 +1,8 @@
-import { objectWithoutEmpty, silenced, urlParentDirectory, urlRoot, urlRoute } from '@noeldemartin/utils';
+import { arrayUnique, objectWithoutEmpty, silenced, urlParentDirectory, urlRoot, urlRoute } from '@noeldemartin/utils';
+
+import SolidStore from '../models/SolidStore';
+import UnauthorizedError from '../errors/UnauthorizedError';
+import type SolidDocument from '../models/SolidDocument';
 
 import { fetchSolidDocument } from './io';
 import type { Fetch } from './io';
@@ -6,6 +10,8 @@ import type { Fetch } from './io';
 export interface SolidUserProfile {
     webId: string;
     storageUrls: string[];
+    cloaked: boolean;
+    writableProfileUrl: string | null;
     name?: string;
     avatarUrl?: string;
     oidcIssuerUrl?: string;
@@ -13,16 +19,79 @@ export interface SolidUserProfile {
     privateTypeIndexUrl?: string;
 }
 
+async function fetchExtendedUserProfile(webIdDocument: SolidDocument, fetch?: Fetch): Promise<{
+    store: SolidStore;
+    cloaked: boolean;
+    writableProfileUrl: string | null;
+}> {
+    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);
+        document
+            .statements(undefined, 'foaf:primaryTopic')
+            .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)) {
+            if (document !== null) {
+                continue;
+            }
+
+            try {
+                const document = await fetchSolidDocument(url, fetch);
+
+                documents[url] = document;
+                store.addQuads(document.getQuads());
+
+                addReferencedDocumentUrls(document);
+            } catch (error) {
+                if (error instanceof UnauthorizedError) {
+                    documents[url] = false;
+
+                    continue;
+                }
+
+                throw error;
+            }
+        }
+    };
+
+    addReferencedDocumentUrls(webIdDocument);
+
+    do {
+        await loadProfileDocuments();
+    } 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,
+    };
+}
+
 async function fetchUserProfile(webId: string, fetch?: Fetch): Promise<SolidUserProfile> {
     const documentUrl = urlRoute(webId);
     const document = await fetchSolidDocument(documentUrl, fetch);
 
-    if (!document.isPersonalProfile())
-        throw new Error(`Document at ${documentUrl} is not a profile.`);
+    if (!document.isPersonalProfile() && !document.contains(webId, 'solid:oidcIssuer')) {
+        throw new Error(`${webId} is not a valid webId.`);
+    }
 
-    const storageUrls = document.statements(webId, 'pim:storage').map(storage => storage.object.value);
-    const publicTypeIndex = document.statement(webId, 'solid:publicTypeIndex');
-    const privateTypeIndex = document.statement(webId, 'solid:privateTypeIndex');
+    const { store, writableProfileUrl, cloaked } = await fetchExtendedUserProfile(document, 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) {
@@ -37,19 +106,23 @@ async function fetchUserProfile(webId: string, fetch?: Fetch): Promise<SolidUser
         parentUrl = urlParentDirectory(parentUrl);
     }
 
-    return objectWithoutEmpty({
+    return {
         webId,
-        storageUrls,
-        name:
-            document.statement(webId, 'vcard:fn')?.object.value ??
-            document.statement(webId, 'foaf:name')?.object.value,
-        avatarUrl:
-            document.statement(webId, 'vcard:hasPhoto')?.object.value ??
-            document.statement(webId, 'foaf:img')?.object.value,
-        oidcIssuerUrl: document.statement(webId, 'solid:oidcIssuer')?.object.value,
-        publicTypeIndexUrl: publicTypeIndex?.object.value,
-        privateTypeIndexUrl: privateTypeIndex?.object.value,
-    });
+        cloaked,
+        writableProfileUrl,
+        storageUrls: arrayUnique(storageUrls),
+        ...objectWithoutEmpty({
+            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,
+            oidcIssuerUrl: store.statement(webId, 'solid:oidcIssuer')?.object.value,
+            publicTypeIndexUrl: publicTypeIndex?.object.value,
+            privateTypeIndexUrl: privateTypeIndex?.object.value,
+        }),
+    };
 }
 
 export async function fetchLoginUserProfile(loginUrl: string, fetch?: Fetch): Promise<SolidUserProfile | null> {

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

@@ -1,57 +1,95 @@
 import { uuid } from '@noeldemartin/utils';
 
 import { createSolidDocument, fetchSolidDocument, solidDocumentExists, updateSolidDocument } from '@/helpers/io';
-import type SolidThing from '@/models/SolidThing';
 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;
+type TypeIndexType = 'public' | 'private';
+
+async function mintTypeIndexUrl(user: SolidUserProfile, type: TypeIndexType, fetch?: Fetch): Promise<string> {
+    fetch = fetch ?? window.fetch.bind(fetch);
 
     const storageUrl = user.storageUrls[0];
-    const typeIndexUrl = `${storageUrl}settings/privateTypeIndex`;
+    const typeIndexUrl = `${storageUrl}settings/${type}TypeIndex`;
 
     return await solidDocumentExists(typeIndexUrl, fetch)
-        ? `${storageUrl}settings/privateTypeIndex-${uuid()}`
+        ? `${storageUrl}settings/${type}TypeIndex-${uuid()}`
         : typeIndexUrl;
 }
 
-export async function createPrivateTypeIndex(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
-    fetch = fetch ?? window.fetch;
+async function createTypeIndex(user: SolidUserProfile, type: TypeIndexType, fetch?: Fetch) {
+    if (user.writableProfileUrl === null) {
+        throw new Error('Can\'t create type index without a writable profile document');
+    }
 
-    const typeIndexUrl = await mintPrivateTypeIndexUrl(user, fetch);
-    const typeIndexBody = `
-        <> a
-            <http://www.w3.org/ns/solid/terms#TypeIndex>,
-            <http://www.w3.org/ns/solid/terms#UnlistedDocument> .
-    `;
+    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> .'
+        : `
+            <> a
+                <http://www.w3.org/ns/solid/terms#TypeIndex>,
+                <http://www.w3.org/ns/solid/terms#UnlistedDocument> .
+        `;
     const profileUpdateBody = `
         INSERT DATA {
-            <${user.webId}> <http://www.w3.org/ns/solid/terms#privateTypeIndex> <${typeIndexUrl}> .
+            <${user.webId}> <http://www.w3.org/ns/solid/terms#${type}TypeIndex> <${typeIndexUrl}> .
         }
     `;
 
-    createSolidDocument(typeIndexUrl, typeIndexBody, fetch);
-    updateSolidDocument(user.webId, profileUpdateBody, fetch);
+    await Promise.all([
+        createSolidDocument(typeIndexUrl, typeIndexBody, fetch),
+        updateSolidDocument(user.writableProfileUrl, profileUpdateBody, fetch),
+    ]);
+
+    if (type === 'public') {
+        // TODO Implement updating ACLs for the listing itself to public
+    }
 
     return typeIndexUrl;
 }
 
-export async function findContainerRegistration(
+async function findRegistrations(
     typeIndexUrl: string,
-    childrenType: string,
+    type: string | string[],
+    predicate: string,
     fetch?: Fetch,
-): Promise<SolidThing | null> {
+): Promise<string[]> {
     const typeIndex = await fetchSolidDocument(typeIndexUrl, fetch);
-    const containerQuad = typeIndex
-        .statements(undefined, 'rdfs:type', 'solid:TypeRegistration')
-        .find(
-            statement =>
-                typeIndex.contains(statement.subject.value, 'solid:forClass', childrenType) &&
-                typeIndex.contains(statement.subject.value, 'solid:instanceContainer'),
-        );
-
-    return containerQuad
-        ? typeIndex.getThing(containerQuad.subject.value) ?? null
-        : null;
+    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();
+}
+
+export async function createPublicTypeIndex(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
+    return createTypeIndex(user, 'public', fetch);
+}
+
+export async function createPrivateTypeIndex(user: SolidUserProfile, fetch?: Fetch): Promise<string> {
+    return createTypeIndex(user, 'private', fetch);
+}
+
+export async function findContainerRegistrations(
+    typeIndexUrl: string,
+    type: string | string[],
+    fetch?: Fetch,
+): Promise<string[]> {
+    return findRegistrations(typeIndexUrl, type, 'solid:instanceContainer', fetch);
+}
+
+export async function findInstanceRegistrations(
+    typeIndexUrl: string,
+    type: string | string[],
+    fetch?: Fetch,
+): Promise<string[]> {
+    return findRegistrations(typeIndexUrl, type, 'solid:instance', fetch);
 }