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

package/src/authn/SolidAuthnLogic.ts

@@ -3,6 +3,7 @@ import { appContext, offlineTestID } from "./authUtil";
 import * as debug from '../util/debug'
 import { Session } from "@inrupt/solid-client-authn-browser";
 import { AuthenticationContext, AuthnLogic } from "../types";
+
 export class SolidAuthnLogic implements AuthnLogic {
   private session: Session;
 
@@ -58,10 +59,10 @@ export class SolidAuthnLogic implements AuthnLogic {
       const curUrl = new URL(window.location.href)
       if (curUrl.hash !== postLoginRedirectHash) {
         if (history.pushState) {
-          // console.log('Setting window.location.has using pushState')
+          // debug.log('Setting window.location.has using pushState')
           history.pushState(null, document.title, postLoginRedirectHash)
         } else {
-          // console.warn('Setting window.location.has using location.hash')
+          // debug.warn('Setting window.location.has using location.hash')
           location.hash = postLoginRedirectHash
         }
         curUrl.hash = postLoginRedirectHash

package/src/chat/chatLogic.ts

@@ -0,0 +1,225 @@
+import { NamedNode, Node, st, term } from "rdflib"
+import { ChatLogic, CreatedPaneOptions, NewPaneOptions, Chat } from "../types"
+import { ns as namespace } from "../util/ns";
+import { determineChatContainer, newThing } from "../util/utils"
+
+const CHAT_LOCATION_IN_CONTAINER = "index.ttl#this"
+
+export function createChatLogic(store, profileLogic): ChatLogic {
+    const ns = namespace
+
+    async function setAcl(
+        chatContainer: NamedNode,
+        me: NamedNode,
+        invitee: NamedNode
+    ): Promise<void> {
+        // Some servers don't present a Link http response header
+        // if the container doesn't exist yet, so refetch the container
+        // now that it has been created:
+        await store.fetcher.load(chatContainer);
+
+        // FIXME: check the Why value on this quad:
+        const chatAclDoc = store.any(
+            chatContainer,
+            new NamedNode("http://www.iana.org/assignments/link-relations/acl")
+        );
+        if (!chatAclDoc) {
+            throw new Error("Chat ACL doc not found!");
+        }
+
+        const aclBody = `
+            @prefix acl: <http://www.w3.org/ns/auth/acl#>.
+            <#owner>
+            a acl:Authorization;
+            acl:agent <${me.value}>;
+            acl:accessTo <.>;
+            acl:default <.>;
+            acl:mode
+                acl:Read, acl:Write, acl:Control.
+            <#invitee>
+            a acl:Authorization;
+            acl:agent <${invitee.value}>;
+            acl:accessTo <.>;
+            acl:default <.>;
+            acl:mode
+                acl:Read, acl:Append.
+            `;
+        await store.fetcher.webOperation("PUT", chatAclDoc.value, {
+            data: aclBody,
+            contentType: "text/turtle",
+        });
+    }
+
+    async function addToPrivateTypeIndex(chatThing, me) {
+        // Add to private type index
+        const privateTypeIndex = store.any(
+            me,
+            ns.solid("privateTypeIndex")
+        ) as NamedNode | null;
+        if (!privateTypeIndex) {
+            throw new Error("Private type index not found!");
+        }
+        await store.fetcher.load(privateTypeIndex);
+        const reg = newThing(privateTypeIndex);
+        const ins = [
+            st(
+                reg,
+                ns.rdf("type"),
+                ns.solid("TypeRegistration"),
+                privateTypeIndex.doc()
+            ),
+            st(
+                reg,
+                ns.solid("forClass"),
+                ns.meeting("LongChat"),
+                privateTypeIndex.doc()
+            ),
+            st(reg, ns.solid("instance"), chatThing, privateTypeIndex.doc()),
+        ];
+        await new Promise((resolve, reject) => {
+            store.updater.update([], ins, function (_uri, ok, errm) {
+                if (!ok) {
+                    reject(new Error(errm));
+                } else {
+                    resolve(null);
+                }
+            });
+        });
+    }
+
+    async function findChat(invitee: NamedNode): Promise<Chat> {
+        const me = await profileLogic.loadMe();
+        const podRoot = await profileLogic.getPodRoot(me);
+        const chatContainer = determineChatContainer(invitee, podRoot);
+        let exists = true;
+        try {
+            await store.fetcher.load(
+                new NamedNode(chatContainer.value + "index.ttl#this")
+            );
+        } catch (e) {
+            exists = false;
+        }
+        return { me, chatContainer, exists };
+    }
+
+    async function createChatThing(
+        chatContainer: NamedNode,
+        me: NamedNode
+    ): Promise<NamedNode> {
+        const created = await mintNew({
+            me,
+            newBase: chatContainer.value,
+        });
+        return created.newInstance;
+    }
+
+    function mintNew(newPaneOptions: NewPaneOptions): Promise<CreatedPaneOptions> {
+        const kb = store;
+        const updater = kb.updater;
+        if (newPaneOptions.me && !newPaneOptions.me.uri) {
+            throw new Error("chat mintNew:  Invalid userid " + newPaneOptions.me);
+        }
+
+        const newInstance = (newPaneOptions.newInstance =
+            newPaneOptions.newInstance ||
+            kb.sym(newPaneOptions.newBase + CHAT_LOCATION_IN_CONTAINER));
+        const newChatDoc = newInstance.doc();
+
+        kb.add(
+            newInstance,
+            ns.rdf("type"),
+            ns.meeting("LongChat"),
+            newChatDoc
+        );
+        kb.add(newInstance, ns.dc("title"), "Chat channel", newChatDoc);
+        kb.add(
+            newInstance,
+            ns.dc("created"),
+            term<Node>(new Date(Date.now())),
+            newChatDoc
+        );
+        if (newPaneOptions.me) {
+            kb.add(newInstance, ns.dc("author"), newPaneOptions.me, newChatDoc);
+        }
+
+        return new Promise(function (resolve, reject) {
+            updater?.put(
+                newChatDoc,
+                kb.statementsMatching(undefined, undefined, undefined, newChatDoc),
+                "text/turtle",
+                function (uri2, ok, message) {
+                    if (ok) {
+                        resolve({
+                            ...newPaneOptions,
+                            newInstance,
+                        });
+                    } else {
+                        reject(
+                            new Error(
+                                "FAILED to save new chat channel at: " + uri2 + " : " + message
+                            )
+                        );
+                    }
+                }
+            );
+        });
+    }
+
+    /**
+     * Find (and optionally create) an individual chat between the current user and the given invitee
+     * @param invitee - The person to chat with
+     * @param createIfMissing - Whether the chat should be created, if missing
+     * @returns null if missing, or a node referring to an already existing chat, or the newly created chat
+     */
+    async function getChat(
+        invitee: NamedNode,
+        createIfMissing = true
+    ): Promise<NamedNode | null> {
+        const { me, chatContainer, exists } = await findChat(invitee);
+        if (exists) {
+            return new NamedNode(chatContainer.value + CHAT_LOCATION_IN_CONTAINER);
+        }
+
+        if (createIfMissing) {
+            const chatThing = await createChatThing(chatContainer, me);
+            await sendInvite(invitee, chatThing);
+            await setAcl(chatContainer, me, invitee);
+            await addToPrivateTypeIndex(chatThing, me);
+            return chatThing;
+        }
+        return null;
+    }
+
+    async function sendInvite(invitee: NamedNode, chatThing: NamedNode) {
+        await store.fetcher.load(invitee.doc());
+        const inviteeInbox = store.any(
+            invitee,
+            ns.ldp("inbox"),
+            undefined,
+            invitee.doc()
+        );
+        if (!inviteeInbox) {
+            throw new Error(`Invitee inbox not found! ${invitee.value}`);
+        }
+        const inviteBody = `
+        <> a <http://www.w3.org/ns/pim/meeting#LongChatInvite> ;
+        ${ns.rdf("seeAlso")} <${chatThing.value}> .
+        `;
+
+        const inviteResponse = await store.fetcher?.webOperation(
+            "POST",
+            inviteeInbox.value,
+            {
+                data: inviteBody,
+                contentType: "text/turtle",
+            }
+        );
+        const locationStr = inviteResponse?.headers.get("location");
+        if (!locationStr) {
+            throw new Error(`Invite sending returned a ${inviteResponse?.status}`);
+        }
+    }
+    return {
+        setAcl, addToPrivateTypeIndex, findChat, createChatThing, getChat, sendInvite, mintNew
+    }
+}

package/src/inbox/inboxLogic.ts

@@ -0,0 +1,58 @@
+import { NamedNode, sym } from "rdflib";
+import { InboxLogic } from "../types";
+import { getArchiveUrl } from "../util/utils";
+
+export function createInboxLogic(store, profileLogic, utilityLogic, containerLogic, aclLogic): InboxLogic {
+  
+    async function createInboxFor(peerWebId: string, nick: string) {
+      const myWebId: NamedNode = await profileLogic.loadMe();
+      const podRoot: NamedNode = await profileLogic.getPodRoot(myWebId);
+      const ourInbox = `${podRoot.value}p2p-inboxes/${encodeURIComponent(nick)}/`;
+      await containerLogic.createContainer(ourInbox);
+      const aclDocUrl = await aclLogic.findAclDocUrl(sym(ourInbox))
+      await utilityLogic.setSinglePeerAccess({
+        ownerWebId: myWebId.value,
+        peerWebId,
+        accessToModes: 'acl:Append',
+        target: ourInbox
+      });
+      return ourInbox;
+  }
+
+  async function getNewMessages(
+      user?: NamedNode
+    ): Promise<NamedNode[]> {
+      if (!user) {
+        user = await profileLogic.loadMe();
+      }
+      const inbox = await profileLogic.getMainInbox(user);
+      const urls = await containerLogic.getContainerMembers(inbox);
+      return urls.filter(url => !containerLogic.isContainer(url));
+  }
+
+  async function markAsRead(url: string, date: Date) {
+    const downloaded = await store.fetcher._fetch(url);
+    if (downloaded.status !== 200) {
+      throw new Error(`Not OK! ${url}`);
+    }
+    const archiveUrl = getArchiveUrl(url, date);
+    const options = {
+      method: 'PUT',
+      body: await downloaded.text(),
+      headers: [
+        ['Content-Type', downloaded.headers.get('Content-Type') || 'application/octet-stream']
+      ]
+    };
+    const uploaded = await store.fetcher._fetch(archiveUrl, options);
+    if (uploaded.status.toString()[0] === '2') {
+      await store.fetcher._fetch(url, {
+        method: 'DELETE'
+      });
+    }
+  }
+  return {
+    createInboxFor,
+    getNewMessages,
+    markAsRead
+  }
+}

package/src/index.ts

@@ -1,39 +1,21 @@
 // Make these variables directly accessible as it is what you need most of the time
 // This also makes these variable globaly accesible in mashlib
 import { solidLogicSingleton } from './logic/solidLogicSingleton'
+
 const authn = solidLogicSingleton.authn
 const authSession = solidLogicSingleton.authn.authSession
 const store = solidLogicSingleton.store
 
-const chat = solidLogicSingleton.chat
-const profile = solidLogicSingleton.profile
-
-export {
-  setACLUserPublic,
-  genACLText
-} from './acl/aclLogic'
-
-export {
-  ensureTypeIndexes,
-  loadTypeIndexes,
-  registerInTypeIndex,
-  loadIndex
-} from './typeIndex/typeIndexLogic'
+export { ACL_LINK } from './acl/aclLogic'
+export { offlineTestID, appContext } from './authn/authUtil'
+export { getSuggestedIssuers } from './issuer/issuerLogic'
+export { AppDetails, SolidNamespace, AuthenticationContext, SolidLogic } from './types'
+export { UnauthorizedError, CrossOriginForbiddenError, SameOriginForbiddenError, NotFoundError, FetchError, NotEditableError, WebOperationError } from './logic/CustomError'
 
 export {
-  loadProfile,
-  loadPreferences,
-  loadTypeIndexesFor,
-  loadCommunityTypeIndexes,
-  loadAllTypeIndexes
-} from './discovery/discoveryLogic'
+  solidLogicSingleton, // solidLogicSingleton is exported entirely because it is used in solid-panes
+  store,
+  authn,
+  authSession
+}
 
-export { SolidLogic } from './logic/SolidLogic'
-export { offlineTestID, appContext } from './authn/authUtil'
-export { ACL_LINK } from './util/UtilityLogic'
-export { getSuggestedIssuers } from './issuer/issuerLogic'
-export { AppDetails, SolidNamespace, AuthenticationContext } from './types'
-// solidLogicSingleton is exported entirely because it is used in solid-panes
-export { solidLogicSingleton } from './logic/solidLogicSingleton'
-export { UnauthorizedError, CrossOriginForbiddenError, SameOriginForbiddenError, NotFoundError, FetchError } from './logic/CustomError'
-export { authn, authSession, store, chat, profile }

package/src/issuer/issuerLogic.ts

@@ -13,7 +13,7 @@ const DEFAULT_ISSUERS = [
   },
   {
     name: 'pod.Inrupt.com',
-    uri: 'https://broker.pod.inrupt.com'
+    uri: 'https://login.inrupt.com'
   }
 ]
 

package/src/logic/CustomError.ts

@@ -6,7 +6,7 @@ class CustomError extends Error {
         this.name = new.target.name; // stack traces display correctly now
     }
 }
-    
+
 export class UnauthorizedError extends CustomError {}
 
 export class CrossOriginForbiddenError extends CustomError {}
@@ -15,6 +15,10 @@ export class SameOriginForbiddenError extends CustomError {}
 
 export class NotFoundError extends CustomError {}
 
+export class NotEditableError extends CustomError { }
+
+export class WebOperationError extends CustomError {}
+
 export class FetchError extends CustomError {
     status: number;
 

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
+    }
+}
+