solid-logic 1.3.12 → 1.3.13-050e3359

package/src/issuer/issuerLogic.ts

@@ -0,0 +1,40 @@
+const DEFAULT_ISSUERS = [
+  {
+    name: 'Solid Community',
+    uri: 'https://solidcommunity.net'
+  },
+  {
+    name: 'Solid Web',
+    uri: 'https://solidweb.org'
+  },
+  {
+    name: 'Inrupt.net',
+    uri: 'https://inrupt.net'
+  },
+  {
+    name: 'pod.Inrupt.com',
+    uri: 'https://broker.pod.inrupt.com'
+  }
+]
+
+/**
+ * @returns - A list of suggested OIDC issuers
+ */
+export function getSuggestedIssuers (): { name: string, uri: string }[] {
+    // Suggest a default list of OIDC issuers
+    const issuers = [...DEFAULT_ISSUERS]
+  
+    // Suggest the current host if not already included
+    const { host, origin } = new URL(location.href)
+    const hosts = issuers.map(({ uri }) => new URL(uri).host)
+    if (!hosts.includes(host) && !hosts.some(existing => isSubdomainOf(host, existing))) {
+      issuers.unshift({ name: host, uri: origin })
+    }
+  
+    return issuers
+  }
+  
+function isSubdomainOf (subdomain: string, domain: string): boolean {
+    const dot = subdomain.length - domain.length - 1
+    return dot > 0 && subdomain[dot] === '.' && subdomain.endsWith(domain)
+}

package/src/logic/CustomError.ts

@@ -0,0 +1,25 @@
+class CustomError extends Error {
+    constructor(message?: string) {
+        super(message);
+        // see: typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html
+        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
+        this.name = new.target.name; // stack traces display correctly now
+    }
+}
+    
+export class UnauthorizedError extends CustomError {}
+
+export class CrossOriginForbiddenError extends CustomError {}
+
+export class SameOriginForbiddenError extends CustomError {}
+
+export class NotFoundError extends CustomError {}
+
+export class FetchError extends CustomError {
+    status: number;
+
+    constructor(status: number, message?: string) {
+        super(message);
+        this.status = status;
+    }
+}

package/src/logic/SolidLogic.ts

@@ -0,0 +1,265 @@
+import { Session } from "@inrupt/solid-client-authn-browser";
+import * as rdf from "rdflib";
+import { NamedNode, Statement, LiveStore } from "rdflib";
+import solidNamespace from "solid-namespace";
+import { SolidAuthnLogic } from "../authn/SolidAuthnLogic";
+import { ChatLogic } from "../chat/ChatLogic";
+import { ProfileLogic } from "../profile/ProfileLogic";
+import { AuthnLogic, SolidNamespace } from "../types";
+import * as debug from "../util/debug";
+import { UtilityLogic } from "../util/UtilityLogic";
+import { CrossOriginForbiddenError, FetchError, NotFoundError, SameOriginForbiddenError, UnauthorizedError } from "./CustomError";
+
+
+const ns: SolidNamespace = solidNamespace(rdf);
+
+export class SolidLogic {
+    cache: {
+        profileDocument: {
+        [WebID: string]: NamedNode;
+        };
+        preferencesFile: {
+        [WebID: string]: NamedNode;
+        };
+    };
+
+    store: LiveStore;
+    me: string | undefined;
+    fetcher: { fetch: (url: string, options?: any) => any };
+
+    chat: ChatLogic;
+    profile: ProfileLogic;
+    authn: AuthnLogic;
+    util: UtilityLogic;
+
+    constructor(fetcher: { fetch: (url: any, requestInit: any) => any }, session: Session) {
+        this.store = rdf.graph() as LiveStore; // Make a Quad store
+        rdf.fetcher(this.store, fetcher); // Attach a web I/O module, store.fetcher
+        this.store.updater = new rdf.UpdateManager(this.store); // Add real-time live updates store.updater
+        this.store.features = [] // disable automatic node merging on store load
+        this.cache = {
+        profileDocument: {},
+        preferencesFile: {},
+        };
+        this.fetcher = fetcher;
+        this.authn = new SolidAuthnLogic(session);
+        debug.log('SolidAuthnLogic initialized')
+        this.profile = new ProfileLogic(this.store, ns, this.authn);
+        this.chat = new ChatLogic(this.store, ns, this.profile);
+        this.util = new UtilityLogic(this.store, ns, this.fetcher);
+    }
+
+    findAclDocUrl(url: string) {
+        return this.util.findAclDocUrl(url);
+    }
+
+    loadDoc(doc: NamedNode): Promise<void> {
+        return this.util.loadDoc(doc);
+    }
+
+    async loadProfile(me: NamedNode): Promise<NamedNode> {
+        // console.log('loadProfile', me)
+        if (this.cache.profileDocument[me.value]) {
+        return this.cache.profileDocument[me.value];
+        }
+        let profileDocument;
+        try {
+        profileDocument = me.doc();
+        await this.loadDoc(profileDocument);
+        return profileDocument;
+        } catch (err) {
+        const message = `Logged in but cannot load profile ${profileDocument} : ${err}`;
+        throw new Error(message);
+        }
+    }
+
+    async loadPreferences(me: NamedNode): Promise<NamedNode> {
+        // console.log('loadPreferences', me)
+        if (this.cache.preferencesFile[me.value]) {
+        return this.cache.preferencesFile[me.value];
+        }
+        const preferencesFile = this.store.any(me, ns.space("preferencesFile"));
+
+        // console.log('this.store.any()', this.store.any())
+        /**
+         * Are we working cross-origin?
+         * Returns True if we are in a webapp at an origin, and the file origin is different
+         */
+        function differentOrigin(): boolean {
+        if (!preferencesFile) {
+            return true;
+        }
+        return (
+            `${window.location.origin}/` !== new URL(preferencesFile.value).origin
+        );
+        }
+
+        if (!preferencesFile) {
+        throw new Error(
+            `Can't find a preference file pointer in profile ${me.doc()}`
+        );
+        }
+
+        if (!this.store.fetcher) {
+        throw new Error("Cannot load doc, have no fetcher");
+        }
+        // //// Load preference file
+        try {
+        await this.store.fetcher.load(preferencesFile as NamedNode, {
+            withCredentials: true,
+        });
+        } catch (err) {
+        // Really important to look at why
+        const status = err.status;
+        debug.log(`HTTP status ${status} for preference file ${preferencesFile}`);
+        if (status === 401) {
+            throw new UnauthorizedError();
+        }
+        if (status === 403) {
+            if (differentOrigin()) {
+            throw new CrossOriginForbiddenError();
+            }
+            throw new SameOriginForbiddenError();
+        }
+        if (status === 404) {
+            throw new NotFoundError(preferencesFile.value);
+        }
+        throw new FetchError(err.status, err.message);
+        }
+        return preferencesFile as NamedNode;
+    }
+
+    getTypeIndex(
+        me: NamedNode | string,
+        preferencesFile: NamedNode | string,
+        isPublic: boolean
+    ): NamedNode[] {
+        // console.log('getTypeIndex', this.store.each(me, undefined, undefined, preferencesFile), isPublic, preferencesFile)
+        return this.store.each(
+        me as NamedNode,
+        isPublic ? ns.solid("publicTypeIndex") : ns.solid("privateTypeIndex"),
+        undefined,
+        preferencesFile as NamedNode
+        ) as NamedNode[];
+    }
+
+    getRegistrations(instance, theClass) {
+        return this.store
+        .each(undefined, ns.solid("instance"), instance)
+        .filter((r) => {
+            return this.store.holds(r, ns.solid("forClass"), theClass);
+        });
+    }
+
+    load(doc: NamedNode | NamedNode[] | string) {
+        if (!this.store.fetcher) {
+        throw new Error("Cannot load doc(s), have no fetcher");
+        }
+        return this.store.fetcher.load(doc);
+    }
+
+    async loadIndexes(
+        me: NamedNode | string,
+        publicProfile: NamedNode | string | null,
+        preferencesFile: NamedNode | string | null,
+        onWarning = async (_err: Error) => {
+            return undefined;
+        }
+    ): Promise<{
+        private: any;
+        public: any;
+    }> {
+        let privateIndexes: any[] = [];
+        let publicIndexes: any[] = [];
+        if (publicProfile) {
+        publicIndexes = this.getTypeIndex(me, publicProfile, true);
+        try {
+            await this.load(publicIndexes as NamedNode[]);
+        } catch (err) {
+            onWarning(new Error(`loadIndex: loading public type index(es) ${err}`));
+        }
+        }
+        if (preferencesFile) {
+        privateIndexes = this.getTypeIndex(me, preferencesFile, false);
+        // console.log({ privateIndexes })
+        if (privateIndexes.length === 0) {
+            await onWarning(
+            new Error(
+                `Your preference file ${preferencesFile} does not point to a private type index.`
+            )
+            );
+        } else {
+            try {
+            await this.load(privateIndexes);
+            } catch (err) {
+            onWarning(
+                new Error(`loadIndex: loading private type index(es) ${err}`)
+            );
+            }
+        }
+        // } else {
+        //   debug.log(
+        //     'We know your preference file is not available, so we are not bothering with private type indexes.'
+        //   )
+        }
+
+        return {
+        private: privateIndexes,
+        public: publicIndexes,
+        };
+    }
+
+    async createEmptyRdfDoc(doc: NamedNode, comment: string) {
+        if (!this.store.fetcher) {
+        throw new Error("Cannot create empty rdf doc, have no fetcher");
+        }
+        await this.store.fetcher.webOperation("PUT", doc.uri, {
+        data: `# ${new Date()} ${comment}
+    `,
+        contentType: "text/turtle",
+        });
+    }
+
+    // @@@@ use the one in rdflib.js when it is available and delete this
+    updatePromise(
+        del: Array<Statement>,
+        ins: Array<Statement> = []
+    ): Promise<void> {
+        return new Promise((resolve, reject) => {
+        if (!this.store.updater) {
+            throw new Error("Cannot updatePromise, have no updater");
+        }
+        this.store.updater.update(del, ins, function (_uri, ok, errorBody) {
+            if (!ok) {
+            reject(new Error(errorBody));
+            } else {
+            resolve();
+            }
+        }); // callback
+        }); // promise
+    }
+
+    isContainer(url: string) {
+        return this.util.isContainer(url);
+    }
+
+    getContainerElements(containerNode: NamedNode): NamedNode[] {
+        return this.util.getContainerElements(containerNode);
+    }
+
+    getContainerMembers(containerUrl: string): Promise<string[]> {
+        return this.util.getContainerMembers(containerUrl);
+    }
+
+    async recursiveDelete(url: string) {
+        return this.util.recursiveDelete(url);
+    }
+
+    clearStore() {
+        return this.util.clearStore();
+    }
+
+    async fetch(url: string, options?: any) {
+        return this.fetcher.fetch(url, options);
+    }
+}

package/src/logic/solidLogicSingleton.ts

@@ -0,0 +1,18 @@
+import * as debug from "../util/debug"
+import { authSession } from "../authSession/authSession"
+import { SolidLogic } from "./SolidLogic"
+
+const _fetch = async (url, requestInit) => {
+    if (authSession.info.webId) {
+        return authSession.fetch(url, requestInit)
+    } else {
+        return window.fetch(url, requestInit)
+    }
+}
+
+//this const makes solidLogicSingleton global accessible in mashlib
+const solidLogicSingleton = new SolidLogic({ fetch: _fetch }, authSession)
+
+debug.log('Unique quadstore initialized.')
+
+export { solidLogicSingleton }

package/src/profile/ProfileLogic.ts

@@ -1,6 +1,5 @@
-import { NamedNode } from "rdflib";
-import { AuthnLogic } from "../authn";
-import { LiveStore, SolidNamespace } from "../index";
+import { NamedNode, LiveStore } from "rdflib";
+import { AuthnLogic, SolidNamespace } from "../types";
 
 export class ProfileLogic {
   store: LiveStore;
@@ -18,7 +17,7 @@ export class ProfileLogic {
     if (me === null) {
       throw new Error("Current user not found! Not logged in?");
     }
-    await this.store.fetcher.load(me.doc());
+    await this.store.fetcher?.load(me.doc());
     return me;
   }
 
@@ -31,7 +30,7 @@ export class ProfileLogic {
   }
 
   async getMainInbox(user: NamedNode): Promise<NamedNode> {
-    await this.store.fetcher.load(user);
+    await this.store.fetcher?.load(user);
     const mainInbox = this.store.any(user, this.ns.ldp("inbox"), undefined, user.doc());
     if (!mainInbox) {
       throw new Error("User main inbox not found!");

package/src/typeIndex/typeIndexLogic.ts

@@ -0,0 +1,170 @@
+import { NamedNode, st, sym } from "rdflib"
+import * as debug from '../util/debug'
+import solidNamespace from 'solid-namespace'
+import * as $rdf from 'rdflib'
+import { newThing } from "../util/uri"
+import { AuthenticationContext } from "../types"
+import { solidLogicSingleton } from "../logic/solidLogicSingleton"
+
+export const ns = solidNamespace($rdf)
+
+/**
+ * Resolves with the same context, outputting
+ * output: index.public, index.private
+ *
+ * @see https://github.com/solid/solid/blob/main/proposals/data-discovery.md#discoverability
+ */
+export async function loadIndex (
+context: AuthenticationContext,
+isPublic: boolean
+): Promise<AuthenticationContext> {
+const indexes = await solidLogicSingleton.loadIndexes(
+    context.me as NamedNode,
+    (isPublic ? context.publicProfile || null : null),
+    (isPublic ? null : context.preferencesFile || null),
+    // async (err: Error) => widgets.complain(context, err.message)
+    async (err: Error) => debug.error(err.message) as undefined
+)
+context.index = context.index || {}
+context.index.private = indexes.private || context.index.private
+context.index.public = indexes.public || context.index.public
+return context
+}
+
+export async function loadTypeIndexes (context: AuthenticationContext) {
+const indexes = await solidLogicSingleton.loadIndexes(
+    context.me as NamedNode,
+    context.publicProfile || null,
+    context.preferencesFile || null,
+    // async (err: Error) => widgets.complain(context, err.message)
+    async (err: Error) => debug.warn(err.message) as undefined
+)
+context.index = context.index || {}
+context.index.private = indexes.private || context.index.private
+context.index.public = indexes.public || context.index.public
+return context
+}
+
+/**
+ * Resolves with the same context, outputting
+ * @see https://github.com/solid/solid/blob/main/proposals/data-discovery.md#discoverability
+ */
+export async function ensureTypeIndexes (context: AuthenticationContext): Promise<AuthenticationContext> {
+await ensureOneTypeIndex(context, true)
+await ensureOneTypeIndex(context, false)
+return context
+}
+
+/**
+ * Load or create ONE type index
+ * Find one or make one or fail
+ * Many reasons for failing including script not having permission etc
+ *
+ * Adds its output to the context
+ * @see https://github.com/solid/solid/blob/main/proposals/data-discovery.md#discoverability
+ */
+async function ensureOneTypeIndex (context: AuthenticationContext, isPublic: boolean): Promise<AuthenticationContext | void> {
+    async function makeIndexIfNecessary (context, isPublic) {
+        const relevant = isPublic ? context.publicProfile : context.preferencesFile
+        const visibility = isPublic ? 'public' : 'private'
+
+        async function putIndex (newIndex) {
+            try {
+                await solidLogicSingleton.createEmptyRdfDoc(newIndex, 'Blank initial Type index')
+                return context
+            } catch (e) {
+                const msg = `Error creating new index ${e}`
+                // widgets.complain(context, msg)
+                debug.warn(msg)
+            }
+        } // putIndex
+
+        context.index = context.index || {}
+        context.index[visibility] = context.index[visibility] || []
+        let newIndex
+        if (context.index[visibility].length === 0) {
+        newIndex = sym(`${relevant.dir().uri + visibility}TypeIndex.ttl`)
+        debug.log(`Linking to new fresh type index ${newIndex}`)
+        if (!confirm(`OK to create a new empty index file at ${newIndex}, overwriting anything that is now there?`)) {
+            throw new Error('cancelled by user')
+        }
+        debug.log(`Linking to new fresh type index ${newIndex}`)
+        const addMe = [
+            st(context.me, ns.solid(`${visibility}TypeIndex`), newIndex, relevant)
+        ]
+        try {
+            await solidLogicSingleton.updatePromise([], addMe)
+        } catch (err) {
+            const msg = `Error saving type index link saving back ${newIndex}: ${err}`
+            //widgets.complain(context, msg)
+            debug.warn(msg)
+            return context
+        }
+
+        debug.log(`Creating new fresh type index file${newIndex}`)
+        await putIndex(newIndex)
+        context.index[visibility].push(newIndex) // @@ wait
+        } else {
+        // officially exists
+        const ixs = context.index[visibility]
+        try {
+            await solidLogicSingleton.load(ixs)
+        } catch (err) {
+            const msg = `ensureOneTypeIndex: loading indexes ${err}`
+            debug.warn(msg)
+            // widgets.complain(context, `ensureOneTypeIndex: loading indexes ${err}`)
+        }
+        }
+    } // makeIndexIfNecessary
+
+    try {
+        await loadIndex(context, isPublic)
+        if (context.index) {
+        debug.log(
+            `ensureOneTypeIndex: Type index exists already ${isPublic
+            ? context.index.public[0]
+            : context.index.private[0]
+            }`
+        )
+        }
+        return context
+    } catch (error) {
+        await makeIndexIfNecessary(context, isPublic)
+        // widgets.complain(context, 'calling loadIndex:' + error)
+    }
+}
+
+/**
+ * Register a new app in a type index
+ * used in chat in bookmark.js (solid-ui)
+ */
+export async function registerInTypeIndex (
+context: AuthenticationContext,
+instance: NamedNode,
+theClass: NamedNode,
+isPublic: boolean
+): Promise<AuthenticationContext> {
+    await ensureOneTypeIndex(context, isPublic)
+    if (!context.index) {
+        throw new Error('registerInTypeIndex: No type index found')
+    }
+    const indexes = isPublic ? context.index.public : context.index.private
+    if (!indexes.length) {
+        throw new Error('registerInTypeIndex: What no type index?')
+    }
+    const index = indexes[0]
+    const registration = newThing(index)
+    const ins = [
+        // See https://github.com/solid/solid/blob/main/proposals/data-discovery.md
+        st(registration, ns.rdf('type'), ns.solid('TypeRegistration'), index),
+        st(registration, ns.solid('forClass'), theClass, index),
+        st(registration, ns.solid('instance'), instance, index)
+    ]
+    try {
+        await solidLogicSingleton.updatePromise([], ins)
+    } catch (e) {
+        debug.log(e)
+        alert(e)
+    }
+    return context
+}

package/src/types.ts

@@ -0,0 +1,43 @@
+import { Session } from "@inrupt/solid-client-authn-browser"
+import { NamedNode } from "rdflib"
+
+export type AppDetails = {
+    noun: string
+    appPathSegment: string
+}
+
+export type AuthenticationContext = {
+    containers?: Array<NamedNode>
+    div?: HTMLElement
+    dom?: HTMLDocument
+    index?: { [key: string]: Array<NamedNode> }
+    instances?: Array<NamedNode>
+    me?: NamedNode | null
+    noun?: string
+    preferencesFile?: NamedNode
+    preferencesFileError?: string
+    publicProfile?: NamedNode
+    statusArea?: HTMLElement
+}
+
+export interface AuthnLogic {
+    authSession: Session //this needs to be deprecated in the future. Is only here to allow imports like panes.UI.authn.authSession prior to moving authn from ui to logic
+    currentUser: () => NamedNode | null
+    checkUser: <T>(setUserCallback?: (me: NamedNode | null) => T) => Promise<NamedNode | T | null>
+    saveUser: (webId: NamedNode | string | null,
+        context?: AuthenticationContext) => NamedNode | null
+}
+
+export interface SolidNamespace {
+    [key: string]: (term: string) => NamedNode
+}
+
+interface NewPaneOptions {
+    me?: NamedNode;
+    newInstance?: NamedNode;
+    newBase: string;
+}
+
+interface CreatedPaneOptions {
+newInstance: NamedNode;
+}

package/src/util/UtilityLogic.ts

@@ -1,22 +1,10 @@
-import { NamedNode, Node, st, term, sym, Statement } from "rdflib";
-import { LiveStore, SolidNamespace } from "../index";
-import { ProfileLogic } from "../profile/ProfileLogic";
-import { newThing } from "../uri";
+import { NamedNode, Statement, sym, LiveStore } from "rdflib";
+import { SolidNamespace } from "../types";
 
 export const ACL_LINK = sym(
   "http://www.iana.org/assignments/link-relations/acl"
 );
 
-interface NewPaneOptions {
-  me?: NamedNode;
-  newInstance?: NamedNode;
-  newBase: string;
-}
-
-interface CreatedPaneOptions {
-  newInstance: NamedNode;
-}
-
 /**
  * Utility-related logic
  */
@@ -33,7 +21,7 @@ export class UtilityLogic {
 
   async findAclDocUrl(url: string) {
     const doc = this.store.sym(url);
-    await this.store.fetcher.load(doc);
+    await this.store.fetcher?.load(doc);
     const docNode = this.store.any(doc, ACL_LINK);
     if (!docNode) {
       throw new Error(`No ACL link discovered for ${url}`);
@@ -137,7 +125,7 @@ export class UtilityLogic {
 
   async getContainerMembers(containerUrl: string): Promise<string[]> {
     const containerNode = this.store.sym(containerUrl);
-    await this.store.fetcher.load(containerNode);
+    await this.store.fetcher?.load(containerNode);
     const nodes = this.getContainerElements(containerNode);
     return nodes.map(node => node.value);
   }

package/test/aclLogic.test.ts

@@ -0,0 +1,15 @@
+import { sym } from 'rdflib'
+import { setACLUserPublic } from '../src/acl/aclLogic' 
+
+describe('setACLUserPublic', () => {
+    it('exists', () => {
+        expect(setACLUserPublic).toBeInstanceOf(Function)
+    })
+    it.skip('runs', async () => {
+        expect(await setACLUserPublic(
+        'https://test.test#',
+        sym('https://test.test#'),
+        {}
+        )).toEqual({})
+    })
+})

package/test/authUtil.test.ts

@@ -0,0 +1,23 @@
+/**
+* @jest-environment jsdom
+* 
+*/
+import * as authUtil from '../src/authn/authUtil'
+
+describe('offlineTestID', () => {
+    it('exists', () => {
+        expect(authUtil.offlineTestID).toBeInstanceOf(Function)
+    })
+    it('runs', () => {
+        expect(authUtil.offlineTestID()).toEqual(null)
+    })
+})
+
+describe('appContext', () => {
+    it('exists', () => {
+        expect(authUtil.appContext).toBeInstanceOf(Function)
+    })
+    it('runs', () => {
+        expect(authUtil.appContext()).toEqual({"viewingNoAuthPage": false,})
+    })
+})