solid-logic 3.1.1-da65b2c → 3.1.1-e3eba68

package/src/profile/profileLogic.ts

@@ -0,0 +1,125 @@
+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)
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } 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
+        }
+
+        try {
+            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

@@ -0,0 +1,198 @@
+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 } from "../util/utils"
+
+export function createTypeIndexLogic(store, authn, profileLogic, utilityLogic): TypeIndexLogic {
+    const ns = namespace
+
+    function getRegistrations(instance, theClass) {
+        return store
+            .each(undefined, ns.solid("instance"), instance)
+            .filter((r) => {
+                return store.holds(r, ns.solid("forClass"), theClass);
+            });
+    }
+
+    async function loadTypeIndexesFor(user: NamedNode): Promise<Array<TypeIndexScope>> {
+        if (!user) throw new Error(`loadTypeIndexesFor: No user given`)
+        const profile = await profileLogic.loadProfile(user)
+
+        const suggestion = suggestPublicTypeIndex(user)
+        let publicTypeIndex
+        try {
+            publicTypeIndex = await utilityLogic.followOrCreateLink(user, ns.solid('publicTypeIndex') as NamedNode, suggestion, profile)
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } 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)
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } catch (err) {
+            preferencesFile = null
+        }
+
+        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 {
+                privateTypeIndex = store.any(user, ns.solid('privateTypeIndex'), undefined, profile) ||
+                    await utilityLogic.followOrCreateLink(user, ns.solid('privateTypeIndex') as NamedNode, suggestedPrivateTypeIndex, preferencesFile);
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                } catch (err) {
+                const message = `User ${user} has no pointer in preference file to privateTypeIndex file.`
+                debug.warn(message)
+            }
+            privateScopes = privateTypeIndex ? [{ label: 'private', index: privateTypeIndex as NamedNode, agent: user }] : []
+        } else {
+            privateScopes = []
+        }
+        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)
+        }
+        return scopes
+    }
+
+    async function loadCommunityTypeIndexes(user: NamedNode): Promise<TypeIndexScope[][]> {
+        let preferencesFile
+        try {
+            preferencesFile = await profileLogic.silencedLoadPreferences(user)
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } 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) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                result = result.concat(await loadTypeIndexesFor(org as NamedNode) as any)
+            }
+            return result
+        }
+        return [] // No communities
+    }
+
+    async function loadAllTypeIndexes(user: NamedNode) {
+        return (await loadTypeIndexesFor(user)).concat((await loadCommunityTypeIndexes(user)).flat())
+    }
+
+    async function getScopedAppInstances(klass: NamedNode, user: NamedNode): Promise<ScopedApp[]> {
+        const scopes = await loadAllTypeIndexes(user)
+        let scopedApps = []
+        for (const scope of scopes) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            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 results: ScopedApp[] = []
+        const registrations = store.statementsMatching(null, ns.solid('instance'), null, index)
+            .concat(store.statementsMatching(null, ns.solid('instanceContainer'), null, index))
+            .map(st => st.subject)
+        for (const reg of registrations) {
+          const klass = store.any(reg, ns.solid('forClass'), null, index)
+          if (!theClass || klass.sameTerm(theClass)) {
+            const instances = store.each(reg, ns.solid('instance'), null, index)
+            for (const instance of instances) {
+              results.push({ instance, type: klass, scope })
+            }
+            const containers = store.each(reg, ns.solid('instanceContainer'), null, index)
+            for (const instance of containers) {
+                await store.fetcher.load(instance)
+                results.push({ instance: sym(instance.value), type: klass,  scope })
+            }
+          }
+        }
+        return results
+    }
+
+    return {
+        registerInTypeIndex,
+        getRegistrations,
+        loadTypeIndexesFor,
+        loadCommunityTypeIndexes,
+        loadAllTypeIndexes,
+        getScopedAppInstances,
+        getAppInstances,
+        suggestPublicTypeIndex,
+        suggestPrivateTypeIndex,
+        deleteTypeIndexRegistration,
+        getScopedAppsFromIndex
+    }
+}

package/src/types.ts

@@ -0,0 +1,122 @@
+import { Session } from "@inrupt/solid-client-authn-browser"
+import { LiveStore, NamedNode, Statement } 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
+}
+
+export type TypeIndexScope = { label: string, index: NamedNode, agent: NamedNode }
+export type ScopedApp = { instance: NamedNode, type: NamedNode, scope: TypeIndexScope }
+
+export interface NewPaneOptions {
+    me?: NamedNode;
+    newInstance?: NamedNode;
+    newBase: string;
+}
+
+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<string | undefined>,
+    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>,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    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/{dist/util/containerLogic.js → src/util/containerLogic.ts}

@@ -1,40 +1,46 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createContainerLogic = createContainerLogic;
-const rdflib_1 = require("rdflib");
+import { NamedNode, Statement, sym } from "rdflib";
+
 /**
  * Container-related class
  */
-function createContainerLogic(store) {
-    function getContainerElements(containerNode) {
+export function createContainerLogic(store) {
+
+    function getContainerElements(containerNode: NamedNode): NamedNode[] {
         return store
-            .statementsMatching(containerNode, (0, rdflib_1.sym)('http://www.w3.org/ns/ldp#contains'), undefined)
-            .map((st) => st.object);
+            .statementsMatching(
+                containerNode,
+                sym("http://www.w3.org/ns/ldp#contains"),
+                undefined
+            )
+            .map((st: Statement) => st.object as NamedNode);
     }
-    function isContainer(url) {
+
+    function isContainer(url: NamedNode) {
         const nodeToString = url.value;
-        return nodeToString.charAt(nodeToString.length - 1) === '/';
+        return nodeToString.charAt(nodeToString.length - 1) === "/";
     }
-    async function createContainer(url) {
-        const stringToNode = (0, rdflib_1.sym)(url);
+
+    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',
+            method: "PUT",
             headers: {
-                'Content-Type': 'text/turtle',
-                'If-None-Match': '*',
+                "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
+            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) {
+
+    async function getContainerMembers(containerUrl: NamedNode): Promise<NamedNode[]> {
         await store.fetcher.load(containerUrl);
         return getContainerElements(containerUrl);
     }
@@ -43,6 +49,5 @@ function createContainerLogic(store) {
         createContainer,
         getContainerElements,
         getContainerMembers
-    };
-}
-//# sourceMappingURL=containerLogic.js.map
+    }
+}

package/src/util/debug.ts

@@ -0,0 +1,20 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export function log(...args: any[]): void {
+  // eslint-disable-next-line no-console
+  console.log(...args);
+}
+
+export function warn(...args: any[]): void {
+  // eslint-disable-next-line no-console
+  console.warn(...args);
+}
+
+export function error(...args: any[]): void {
+  // eslint-disable-next-line no-console
+  console.error(...args);
+}
+
+export function trace(...args: any[]): void {
+  // eslint-disable-next-line no-console
+  console.trace(...args);
+}

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)