solid-logic 1.3.17-615b75c1 → 1.3.17-6e0634d8

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
 }

package/src/types.ts

@@ -1,5 +1,5 @@
 import { Session } from "@inrupt/solid-client-authn-browser"
-import { NamedNode } from "rdflib"
+import { LiveStore, NamedNode, Statement } from "rdflib"
 
 export type AppDetails = {
     noun: string
@@ -32,12 +32,91 @@ export interface SolidNamespace {
     [key: string]: (term: string) => NamedNode
 }
 
-interface NewPaneOptions {
+export type TypeIndexScope = { label: string, index: NamedNode, agent: NamedNode }
+export type ScopedApp = { instance: NamedNode, scope: TypeIndexScope }
+
+export interface NewPaneOptions {
     me?: NamedNode;
     newInstance?: NamedNode;
     newBase: string;
 }
 
-interface CreatedPaneOptions {
+export interface CreatedPaneOptions {
 newInstance: NamedNode;
-}
+}
+
+export interface ChatLogic {
+    setAcl: (chatContainer: NamedNode, me: NamedNode, invitee: NamedNode) => Promise<void>,
+    addToPrivateTypeIndex: (chatThing, me) => void | Promise<void>,
+    findChat: (invitee: NamedNode) => Promise<Chat>,
+    createChatThing: (chatContainer: NamedNode, me: NamedNode) => Promise<NamedNode>,
+    mintNew: (newPaneOptions: NewPaneOptions) => Promise<CreatedPaneOptions>,
+    getChat: (invitee: NamedNode, boolean) => Promise<NamedNode | null>,
+    sendInvite: (invitee: NamedNode, chatThing: NamedNode) => void
+}
+
+export interface Chat {
+    me: NamedNode,
+    chatContainer: NamedNode,
+    exists: boolean
+}
+
+export interface ProfileLogic {
+    silencedLoadPreferences: (user: NamedNode) => Promise<NamedNode | undefined>,
+    loadPreferences: (user: NamedNode) => Promise<NamedNode>,
+    loadProfile: (user: NamedNode) => Promise<NamedNode>,
+    loadMe: () => Promise<NamedNode>,
+    getPodRoot: (user: NamedNode) => NamedNode,
+    getMainInbox: (user: NamedNode) => Promise<NamedNode>,
+    findStorage: (me: NamedNode) => Node | null
+}
+
+export interface AclLogic {
+    findAclDocUrl: (url: NamedNode) => Promise<any>,
+    setACLUserPublic: (docURI: string, me: NamedNode,
+        options: {
+            defaultForNew?: boolean,
+            public?: []
+        }
+    ) => Promise<NamedNode>,
+    genACLText: (docURI: string, me: NamedNode, aclURI: string,
+        options: {
+            defaultForNew?: boolean,
+            public?: []
+        }
+    ) => string | undefined
+}
+
+export interface InboxLogic {
+    createInboxFor: (peerWebId: string, nick: string) => Promise<string>,
+    getNewMessages: (user?: NamedNode) => Promise<NamedNode[]>,
+    markAsRead: (url: string, date: Date) => void
+}
+
+export interface TypeIndexLogic {
+    getRegistrations: (instance, theClass) => Node[],
+    loadTypeIndexesFor: (user: NamedNode) => Promise<Array<TypeIndexScope>>,
+    loadCommunityTypeIndexes: (user: NamedNode) => Promise<TypeIndexScope[][]>,
+    loadAllTypeIndexes: (user: NamedNode) => Promise<Array<TypeIndexScope>>,
+    getScopedAppInstances: (klass: NamedNode, user: NamedNode) => Promise<ScopedApp[]>,
+    getAppInstances: (klass: NamedNode) => Promise<NamedNode[]>,
+    suggestPublicTypeIndex: (me: NamedNode) => NamedNode,
+    suggestPrivateTypeIndex: (preferencesFile: NamedNode) => NamedNode,
+    registerInTypeIndex: (instance: NamedNode, index: NamedNode, theClass: NamedNode) => Promise<NamedNode | null>,
+    deleteTypeIndexRegistration: (item: any) => Promise<void>
+    getScopedAppsFromIndex: (scope: TypeIndexScope, theClass: NamedNode | null) => Promise<ScopedApp[]>
+}
+
+export interface SolidLogic {
+    store: LiveStore,
+    authn: AuthnLogic,
+    acl: AclLogic,
+    profile: ProfileLogic,
+    inbox: InboxLogic,
+    typeIndex: TypeIndexLogic,
+    chat: ChatLogic,
+    load: (doc: NamedNode | NamedNode[] | string) => void,
+    updatePromise: (del: Array<Statement>, ins: Array<Statement>) => Promise<void>,
+    clearStore: () => void
+}
+

package/src/util/containerLogic.ts

@@ -0,0 +1,53 @@
+import { NamedNode, Statement, sym } from "rdflib";
+
+/**
+ * Container-related class
+ */
+export function createContainerLogic(store) {
+
+    function getContainerElements(containerNode: NamedNode): NamedNode[] {
+        return store
+            .statementsMatching(
+                containerNode,
+                sym("http://www.w3.org/ns/ldp#contains"),
+                undefined
+            )
+            .map((st: Statement) => st.object as NamedNode);
+    }
+
+    function isContainer(url: NamedNode) {
+        const nodeToString = url.value;
+        return nodeToString.charAt(nodeToString.length - 1) === "/";
+    }
+
+    async function createContainer(url: string) {
+        const stringToNode = sym(url);
+        if (!isContainer(stringToNode)) {
+            throw new Error(`Not a container URL ${url}`);
+        }
+        // Copied from https://github.com/solidos/solid-crud-tests/blob/v3.1.0/test/surface/create-container.test.ts#L56-L64
+        const result = await store.fetcher._fetch(url, {
+            method: "PUT",
+            headers: {
+                "Content-Type": "text/turtle",
+                "If-None-Match": "*",
+                Link: '<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"', // See https://github.com/solidos/node-solid-server/issues/1465
+            },
+            body: " ", // work around https://github.com/michielbdejong/community-server/issues/4#issuecomment-776222863
+        });
+        if (result.status.toString()[0] !== '2') {
+            throw new Error(`Not OK: got ${result.status} response while creating container at ${url}`);
+        }
+    }
+
+    async function getContainerMembers(containerUrl: NamedNode): Promise<NamedNode[]> {
+        await store.fetcher.load(containerUrl);
+        return getContainerElements(containerUrl);
+    }
+    return {
+        isContainer,
+        createContainer,
+        getContainerElements,
+        getContainerMembers
+    }
+}

package/src/util/ns.ts

@@ -0,0 +1,5 @@
+// Namespaces we commonly use and have common prefixes for around Solid
+import solidNamespace from 'solid-namespace' // Delegate to this which takes RDFlib as param.
+import * as $rdf from 'rdflib'
+
+export const ns = solidNamespace($rdf)