solid-logic 1.3.17-9d25ceb7 → 1.3.17-a4538ffc

package/src/logic/solidLogic.ts

@@ -0,0 +1,75 @@
+import { Session } from "@inrupt/solid-client-authn-browser";
+import * as rdf from "rdflib";
+import { LiveStore, NamedNode, Statement } from "rdflib";
+import { createAclLogic } from "../acl/aclLogic";
+import { SolidAuthnLogic } from "../authn/SolidAuthnLogic";
+import { createChatLogic } from "../chat/chatLogic";
+import { createInboxLogic } from "../inbox/inboxLogic";
+import { createProfileLogic } from "../profile/profileLogic";
+import { createTypeIndexLogic } from "../typeIndex/typeIndexLogic";
+import { createContainerLogic } from "../util/containerLogic";
+import { createUtilityLogic } from "../util/utilityLogic";
+import { AuthnLogic, SolidLogic } from "../types";
+import * as debug from "../util/debug";
+/*
+** It is important to distinquish `fetch`, a function provided by the browser
+** and `Fetcher`, a helper object for the rdflib Store which turns it
+** into a `ConnectedStore` or a `LiveStore`.  A Fetcher object is
+** available at store.fetcher, and `fetch` function at `store.fetcher._fetch`,
+*/
+export function createSolidLogic(specialFetch: { fetch: (url: any, requestInit: any) => any }, session: Session): SolidLogic {
+
+    debug.log("SolidLogic: Unique instance created.  There should only be one of these.")
+    const store: LiveStore = rdf.graph() as LiveStore
+    rdf.fetcher(store, {fetch: specialFetch.fetch}); // Attach a web I/O module, store.fetcher
+    store.updater = new rdf.UpdateManager(store); // Add real-time live updates store.updater
+    store.features = [] // disable automatic node merging on store load
+
+    const authn: AuthnLogic = new SolidAuthnLogic(session)
+    
+    const acl = createAclLogic(store)
+    const containerLogic = createContainerLogic(store)
+    const utilityLogic = createUtilityLogic(store, acl, containerLogic)
+    const profile = createProfileLogic(store, authn, utilityLogic)
+    const chat = createChatLogic(store, profile)
+    const inbox = createInboxLogic(store, profile, utilityLogic, containerLogic, acl)
+    const typeIndex = createTypeIndexLogic(store, authn, profile, utilityLogic)
+    debug.log('SolidAuthnLogic initialized')
+
+    function load(doc: NamedNode | NamedNode[] | string) {
+        return store.fetcher.load(doc);
+    }
+
+    // @@@@ use the one in rdflib.js when it is available and delete this
+    function updatePromise(
+        del: Array<Statement>,
+        ins: Array<Statement> = []
+    ): Promise<void> {
+        return new Promise((resolve, reject) => {
+        store.updater.update(del, ins, function (_uri, ok, errorBody) {
+            if (!ok) {
+            reject(new Error(errorBody));
+            } else {
+            resolve();
+            }
+        }); // callback
+        }); // promise
+    }
+
+    function clearStore() {
+        store.statements.slice().forEach(store.remove.bind(store));
+    }
+
+    return {
+        store,
+        authn,
+        acl,
+        inbox,
+        chat,
+        profile,
+        typeIndex,
+        load,
+        updatePromise,
+        clearStore
+    }
+}

package/src/logic/solidLogicSingleton.ts

@@ -1,11 +1,11 @@
 import * as debug from "../util/debug"
 import { authSession } from "../authSession/authSession"
-import { SolidLogic } from "./SolidLogic"
+import { createSolidLogic } from "./solidLogic"
 
 const _fetch = async (url, requestInit) => {
     const omitCreds = requestInit && requestInit.credentials && requestInit.credentials == 'omit'
     if (authSession.info.webId && !omitCreds) { // see https://github.com/solidos/solidos/issues/114
-        // In fact ftech should respect crentials omit itself
+        // In fact fetch should respect credentials omit itself
         return authSession.fetch(url, requestInit)
     } else {
         return window.fetch(url, requestInit)
@@ -13,7 +13,7 @@ const _fetch = async (url, requestInit) => {
 }
 
 //this const makes solidLogicSingleton global accessible in mashlib
-const solidLogicSingleton = new SolidLogic({ fetch: _fetch }, authSession)
+const solidLogicSingleton = createSolidLogic({ fetch: _fetch }, authSession)
 
 debug.log('Unique quadstore initialized.')
 

package/src/profile/profileLogic.ts

@@ -0,0 +1,126 @@
+import { NamedNode } from "rdflib";
+import { CrossOriginForbiddenError, FetchError, NotEditableError, SameOriginForbiddenError, UnauthorizedError, WebOperationError } from "../logic/CustomError";
+import * as debug from "../util/debug";
+import { ns as namespace } from '../util/ns';
+import { differentOrigin, suggestPreferencesFile } from "../util/utils"
+import { ProfileLogic } from "../types"
+
+export function createProfileLogic(store, authn, utilityLogic): ProfileLogic {
+    const ns = namespace
+
+    /**
+     * loads the preference without throwing errors - if it can create it it does so.
+     * remark: it still throws error if it cannot load profile.
+     * @param user 
+     * @returns undefined if preferenceFile cannot be returned or NamedNode if it can find it or create it
+     */
+    async function silencedLoadPreferences(user: NamedNode): Promise <NamedNode | undefined> {
+        try {
+            return await loadPreferences(user)
+        } catch (err) {
+            return undefined
+        }
+    }
+
+    /**
+     * loads the preference without returning different errors if it cannot create or load it.
+     * remark: it also throws error if it cannot load profile.
+     * @param user 
+     * @returns undefined if preferenceFile cannot be an Error or NamedNode if it can find it or create it
+     */
+    async function loadPreferences (user: NamedNode): Promise <NamedNode> {
+        await loadProfile(user)
+
+        const possiblePreferencesFile = suggestPreferencesFile(user)
+        let preferencesFile
+        try {
+            preferencesFile = await utilityLogic.followOrCreateLink(user, ns.space('preferencesFile') as NamedNode, possiblePreferencesFile, user.doc())
+        } catch (err) {
+            const message = `User ${user} has no pointer in profile to preferences file.`
+            debug.warn(message)
+            // we are listing the possible errors
+            if (err instanceof NotEditableError) { throw err }
+            if (err instanceof WebOperationError) { throw err }
+            if (err instanceof UnauthorizedError) { throw err }
+            if (err instanceof CrossOriginForbiddenError) { throw err }
+            if (err instanceof SameOriginForbiddenError) { throw err }
+            if (err instanceof FetchError) { throw err }
+            throw err
+        }
+
+        let response
+        try {
+            response = await store.fetcher.load(preferencesFile as NamedNode)
+        } catch (err) { // Maybe a permission problem or origin problem
+            const msg = `Unable to load preference of user ${user}: ${err}`
+            debug.warn(msg)
+            if (err.response.status === 401) {
+                throw new UnauthorizedError();
+            }
+            if (err.response.status === 403) {
+                if (differentOrigin(preferencesFile)) {
+                throw new CrossOriginForbiddenError();
+                }
+                throw new SameOriginForbiddenError();
+            }
+            /*if (err.response.status === 404) {
+                throw new NotFoundError();
+            }*/
+            throw new Error(msg)
+        }
+        return preferencesFile as NamedNode
+    }
+
+    async function loadProfile (user: NamedNode):Promise <NamedNode> {
+        if (!user) {
+            throw new Error(`loadProfile: no user given.`)
+        }
+        try {
+            await store.fetcher.load(user.doc())
+        } catch (err) {
+            throw new Error(`Unable to load profile of user ${user}: ${err}`)
+        }
+        return user.doc()
+    }
+
+    async function loadMe(): Promise<NamedNode> {
+        const me = authn.currentUser();
+        if (me === null) {
+            throw new Error("Current user not found! Not logged in?");
+        }
+        await store.fetcher.load(me.doc());
+        return me;
+    }
+
+    function getPodRoot(user: NamedNode): NamedNode {
+        const podRoot = findStorage(user);
+        if (!podRoot) {
+            throw new Error("User pod root not found!");
+        }
+        return podRoot as NamedNode;
+    }
+
+    async function getMainInbox(user: NamedNode): Promise<NamedNode> {
+        await store.fetcher.load(user);
+        const mainInbox = store.any(user, ns.ldp("inbox"), undefined, user.doc());
+        if (!mainInbox) {
+            throw new Error("User main inbox not found!");
+        }
+        return mainInbox as NamedNode;
+    }
+
+    function findStorage(me: NamedNode) {
+        return store.any(me, ns.space("storage"), undefined, me.doc());
+    }
+
+    return {
+        loadMe,
+        getPodRoot,
+        getMainInbox,
+        findStorage,
+        loadPreferences,
+        loadProfile,
+        silencedLoadPreferences
+    }
+}
+

package/src/typeIndex/typeIndexLogic.ts

@@ -1,201 +1,194 @@
-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"
-// import { ensureLoadedPreferences } from '../logic/logic'
-import { loadPreferences, loadProfile } from '../discovery/discoveryLogic'
-export const ns = solidNamespace($rdf)
-
-const store = solidLogicSingleton.store
-
-async function ensureLoadedPreferences (context:AuthenticationContext) {
-  if (!context.me) throw new Error('@@ ensureLoadedPreferences: no user specified')
-  context.publicProfile = await loadProfile(store, context.me)
-  context.preferencesFile = await loadPreferences(store, context.me)
-  return context
-}
+import { NamedNode, st, sym } from 'rdflib'
+import { ScopedApp, TypeIndexLogic, TypeIndexScope } from '../types'
+import * as debug from "../util/debug"
+import { ns as namespace } from '../util/ns'
+import { newThing, uniqueNodes } from "../util/utils"
 
-/**
- * Resolves with the same context, outputting
- * output: index.public, index.private
- *  @@ This is a very bizare function
- * @see https://github.com/solidos/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.concat(context.index.private || []) // otherwise concat will wrongly add 'undefined' as a private index
-context.index.public = indexes.public.concat(context.index.public || []) // otherwise concat will wrongly add 'undefined' as a public index
-return context
-}
+export function createTypeIndexLogic(store, authn, profileLogic, utilityLogic): TypeIndexLogic {
+    const ns = namespace
 
-export async function loadTypeIndexes (context: AuthenticationContext) {
-    try {
-        await loadPreferences(solidLogicSingleton.store, context.me as NamedNode)
-    } catch (error) {
-        debug.warn(error.message) as undefined
-    }
-    try {
-        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
-    } catch (error) {
-        async (error: Error) => debug.warn(error.message) as undefined
+    function getRegistrations(instance, theClass) {
+        return store
+            .each(undefined, ns.solid("instance"), instance)
+            .filter((r) => {
+                return store.holds(r, ns.solid("forClass"), theClass);
+            });
     }
-}
 
-/**
- * Resolves with the same context, outputting
- * @see https://github.com/solidos/solid/blob/main/proposals/data-discovery.md#discoverability
- */
-export async function ensureTypeIndexes (context: AuthenticationContext, agent?: NamedNode): Promise<AuthenticationContext> {
-if (!context.me) {
-  throw new Error(`ensureTypeIndexes: @@ no user`)
-}
-await ensureOneTypeIndex(context, true, agent)
-await ensureOneTypeIndex(context, false, agent)
-return context
-}
+    async function loadTypeIndexesFor(user: NamedNode): Promise<Array<TypeIndexScope>> {
+        if (!user) throw new Error(`loadTypeIndexesFor: No user given`)
+        const profile = await profileLogic.loadProfile(user)
 
-/**
- * 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/solidos/solid/blob/main/proposals/data-discovery.md#discoverability
- */
-async function ensureOneTypeIndex (context: AuthenticationContext, isPublic: boolean, agent?: NamedNode): Promise<AuthenticationContext | void> {
-    async function makeIndexIfNecessary (context, isPublic) {
-        const relevant = isPublic ? context.publicProfile : context.preferencesFile
-        if (!relevant) alert ('@@@@ relevent null')
-        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
+        const suggestion = suggestPublicTypeIndex(user)
+        let publicTypeIndex
+        try {
+            publicTypeIndex = await utilityLogic.followOrCreateLink(user, ns.solid('publicTypeIndex') as NamedNode, suggestion, profile)
+        } catch (err) {
+            const message = `User ${user} has no pointer in profile to publicTypeIndex file.`
+            debug.warn(message)
+        }
+        const publicScopes = publicTypeIndex ? [{ label: 'public', index: publicTypeIndex as NamedNode, agent: user }] : []
 
+        let preferencesFile
+        try {
+            preferencesFile = await profileLogic.silencedLoadPreferences(user)
+        } catch (err) {
+            preferencesFile = null
+        }
 
-        context.index = context.index || {}
-        context.index[visibility] = context.index[visibility] || []
-        let newIndex
-        if (context.index[visibility].length === 0) {
-            if (!store.updater.editable(relevant)) {
-              debug.log(`Not adding new type index as ${relevant} is not editable`)
-              return
-            }
-            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)
-            ]
+        let privateScopes
+        if (preferencesFile) { // watch out - can be in either as spec was not clear.  Legacy is profile.
+            // If there is a legacy one linked from the profile, use that.
+            // Otherwiae use or make one linked from Preferences
+            const suggestedPrivateTypeIndex = suggestPrivateTypeIndex(preferencesFile)
+            let privateTypeIndex
             try {
-                await solidLogicSingleton.updatePromise([], addMe)
+                privateTypeIndex = store.any(user, ns.solid('privateTypeIndex'), undefined, profile) ||
+                    await utilityLogic.followOrCreateLink(user, ns.solid('privateTypeIndex') as NamedNode, suggestedPrivateTypeIndex, preferencesFile);
             } catch (err) {
-                const msg = `Error saving type index link saving back ${newIndex}: ${err}`
-                //widgets.complain(context, msg)
-                debug.warn(msg)
-                return context
+                const message = `User ${user} has no pointer in preference file to privateTypeIndex file.`
+                debug.warn(message)
             }
-
-            debug.log(`Creating new fresh type index file${newIndex}`)
-            await putIndex(newIndex)
-            context.index[visibility].push(newIndex) // @@ wait
+            privateScopes = privateTypeIndex ? [{ label: 'private', index: privateTypeIndex as NamedNode, agent: user }] : []
         } 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}`)
-          }
+            privateScopes = []
         }
-    } // makeIndexIfNecessary
-
-    const context2 = await ensureLoadedPreferences(context)
-    if (!context2.publicProfile) throw new Error(`@@ type index: no publicProfile`)
-    if (!context2.preferencesFile) throw new Error(`@@ type index: no preferencesFile for profile  ${context2.publicProfile}`)
-    const relevant = isPublic ? context2.publicProfile : context2.preferencesFile
-
-    try {
-        await loadIndex(context2, isPublic)
-        const pp = isPublic ? 'public' : 'private'
-        if (context2.index && context2.index[pp]&& context2.index[pp].length > 0) {
-          debug.log(`ensureOneTypeIndex: Type index exists already ${context2.index[pp]}`)
-          return context2
+        const scopes = publicScopes.concat(privateScopes)
+        if (scopes.length === 0) return scopes
+        const files = scopes.map(scope => scope.index)
+        try {
+            await store.fetcher.load(files)
+        } catch (err) {
+            debug.warn('Problems loading type index: ', err)
         }
-        await makeIndexIfNecessary(context2, isPublic)
-    } catch (error) {
-        await makeIndexIfNecessary(context2, isPublic)
-        // widgets.complain(context2, 'calling loadIndex:' + error)
+        return scopes
+    }
+
+    async function loadCommunityTypeIndexes(user: NamedNode): Promise<TypeIndexScope[][]> {
+        let preferencesFile
+        try {
+            preferencesFile = await profileLogic.silencedLoadPreferences(user)
+        } catch (err) {
+            const message = `User ${user} has no pointer in profile to preferences file.`
+            debug.warn(message)
+        }
+        if (preferencesFile) { // For now, pick up communities as simple links from the preferences file.
+            const communities = store.each(user, ns.solid('community'), undefined, preferencesFile as NamedNode).concat(
+                store.each(user, ns.solid('community'), undefined, user.doc() as NamedNode)
+            )
+            let result = []
+            for (const org of communities) {
+                result = result.concat(await loadTypeIndexesFor(org as NamedNode) as any)
+            }
+            return result
+        }
+        return [] // No communities
     }
-}
 
-/**
- * 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,
-agent?: NamedNode // Defaults to current user
-): Promise<AuthenticationContext> {
-    await ensureOneTypeIndex(context, isPublic, agent)
-    if (!context.index) {
-        throw new Error('registerInTypeIndex: No type index found')
+    async function loadAllTypeIndexes(user: NamedNode) {
+        return (await loadTypeIndexesFor(user)).concat((await loadCommunityTypeIndexes(user)).flat())
     }
-    const indexes = isPublic ? context.index.public : context.index.private
-    if (!indexes.length) {
-        throw new Error('registerInTypeIndex: What no type index?')
+
+    async function getScopedAppInstances(klass: NamedNode, user: NamedNode): Promise<ScopedApp[]> {
+        const scopes = await loadAllTypeIndexes(user)
+        let scopedApps = []
+        for (const scope of scopes) {
+            const scopedApps0 = await getScopedAppsFromIndex(scope, klass) as any
+            scopedApps = scopedApps.concat(scopedApps0)
+        }
+        return scopedApps
+    }
+
+    // This is the function signature which used to be in solid-ui/logic
+    // Recommended to use getScopedAppInstances instead as it provides more information.
+    //
+    async function getAppInstances(klass: NamedNode): Promise<NamedNode[]> {
+        const user = authn.currentUser()
+        if (!user) throw new Error('getAppInstances: Must be logged in to find apps.')
+        const scopedAppInstances = await getScopedAppInstances(klass, user)
+        return scopedAppInstances.map(scoped => scoped.instance)
+    }
+
+    function suggestPublicTypeIndex(me: NamedNode) {
+        return sym(me.doc().dir()?.uri + 'publicTypeIndex.ttl')
+    }
+    // Note this one is based off the pref file not the profile
+
+    function suggestPrivateTypeIndex(preferencesFile: NamedNode) {
+        return sym(preferencesFile.doc().dir()?.uri + 'privateTypeIndex.ttl')
+    }
+
+    /*
+    * Register a new app in a type index
+    * used in chat in bookmark.js (solid-ui)
+    * Returns the registration object if successful else null
+    */
+    async function registerInTypeIndex(
+        instance: NamedNode,
+        index: NamedNode,
+        theClass: NamedNode,
+        // agent: NamedNode
+    ): Promise<NamedNode | null> {
+        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 store.updater.update([], ins)
+        } catch (err) {
+            const msg = `Unable to register ${instance} in index ${index}: ${err}`
+            console.warn(msg)
+            return null
+        }
+        return registration
+    }
+
+    async function deleteTypeIndexRegistration(item) {
+        const reg = store.the(null, ns.solid('instance'), item.instance, item.scope.index) as NamedNode
+        if (!reg) throw new Error(`deleteTypeIndexRegistration: No registration found for ${item.instance}`)
+        const statements = store.statementsMatching(reg, null, null, item.scope.index)
+        await store.updater.update(statements, [])
+    }
+
+    async function getScopedAppsFromIndex(scope: TypeIndexScope, theClass: NamedNode | null): Promise<ScopedApp[]> {
+        const index = scope.index
+        const registrations = store.statementsMatching(null, ns.solid('instance'), null, index)
+            .concat(store.statementsMatching(null, ns.solid('instanceContainer'), null, index))
+            .map(st => st.subject)
+        const relevant = theClass ? registrations.filter(reg => store.any(reg, ns.solid('forClass'), null, index)?.sameTerm(theClass))
+            : registrations
+        const directInstances = relevant.map(reg => store.each(reg, ns.solid('instance'), null, index).map(one => sym(one.value))).flat()
+        let instances = uniqueNodes(directInstances)
+
+        const instanceContainers = relevant.map(
+            reg => store.each(reg, ns.solid('instanceContainer'), null, index).map(one => sym(one.value))).flat()
+
+        //  instanceContainers may be deprocatable if no one has used them
+        const containers = uniqueNodes(instanceContainers)
+        if (containers.length > 0) { console.log('@@ getScopedAppsFromIndex containers ', containers) }
+        for (let i = 0; i < containers.length; i++) {
+            const cont = containers[i]
+            await store.fetcher.load(cont)
+            const contents = store.each(cont, ns.ldp('contains'), null, cont).map(one => sym(one.value))
+            instances = instances.concat(contents)
+        }
+        return instances.map(instance => { return { instance, scope } })
     }
-    const index = indexes[0]
-    const registration = newThing(index)
-    const ins = [
-        // See https://github.com/solidos/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 {
+        registerInTypeIndex,
+        getRegistrations,
+        loadTypeIndexesFor,
+        loadCommunityTypeIndexes,
+        loadAllTypeIndexes,
+        getScopedAppInstances,
+        getAppInstances,
+        suggestPublicTypeIndex,
+        suggestPrivateTypeIndex,
+        deleteTypeIndexRegistration,
+        getScopedAppsFromIndex
     }
-    return context
 }