solid-logic 1.3.17 → 2.0.0-30dbc72f

package/src/acl/aclLogic.ts

@@ -1,137 +1,156 @@
-/**
- * Simple Access Control
- *
- * This function sets up a simple default ACL for a resource, with
- * RWC for the owner, and a specified access (default none) for the public.
- * In all cases owner has read write control.
- * Parameter lists modes allowed to public
- *
- * @param options
- * @param options.public eg ['Read', 'Write']
- *
- * @returns Resolves with aclDoc uri on successful write
- */
+import { graph, NamedNode, Namespace, serialize, sym } from "rdflib"
+import { AclLogic } from "../types";
+import { ns as namespace } from '../util/ns'
 
-import { graph, NamedNode, Namespace, serialize } from "rdflib"
-import solidNamespace from 'solid-namespace'
-import * as $rdf from 'rdflib'
-import { solidLogicSingleton } from "../logic/solidLogicSingleton"
-import { ACL_LINK } from "../util/UtilityLogic"
 
-export const ns = solidNamespace($rdf)
+export const ACL_LINK = sym(
+    "http://www.iana.org/assignments/link-relations/acl"
+);
 
-export function setACLUserPublic ( 
-docURI: string,
-me: NamedNode,
-options: {
-    defaultForNew?: boolean,
-    public?: []
-}
-): Promise<NamedNode> {
-const aclDoc = solidLogicSingleton.store.any(
-    solidLogicSingleton.store.sym(docURI),
-    ACL_LINK
-)
+export function createAclLogic(store): AclLogic {
 
-return Promise.resolve()
-    .then(() => {
-    if (aclDoc) {
-        return aclDoc as NamedNode
+    const ns = namespace
+    
+    async function findAclDocUrl(url: string) {
+        const doc = store.sym(url);
+        await store.fetcher.load(doc);
+        const docNode = store.any(doc, ACL_LINK);
+        if (!docNode) {
+            throw new Error(`No ACL link discovered for ${url}`);
+        }
+        return docNode.value;
     }
-
-    return fetchACLRel(docURI).catch(err => {
-        throw new Error(`Error fetching rel=ACL header for ${docURI}: ${err}`)
-    })
-    })
-    .then(aclDoc => {
-    const aclText = genACLText(docURI, me, aclDoc.uri, options)
-    if (!solidLogicSingleton.store.fetcher) {
-        throw new Error('Cannot PUT this, store has no fetcher')
+    /**
+     * Simple Access Control
+     *
+     * This function sets up a simple default ACL for a resource, with
+     * RWC for the owner, and a specified access (default none) for the public.
+     * In all cases owner has read write control.
+     * Parameter lists modes allowed to public
+     *
+     * @param options
+     * @param options.public eg ['Read', 'Write']
+     *
+     * @returns Resolves with aclDoc uri on successful write
+     */
+    function setACLUserPublic ( 
+    docURI: string,
+    me: NamedNode,
+    options: {
+        defaultForNew?: boolean,
+        public?: []
     }
-    return solidLogicSingleton.store.fetcher
-        .webOperation('PUT', aclDoc.uri, {
-        data: aclText,
-        contentType: 'text/turtle'
-        })
-        .then(result => {
-        if (!result.ok) {
-            throw new Error('Error writing ACL text: ' + result.error)
+    ): Promise<NamedNode> {
+    const aclDoc = store.any(
+        store.sym(docURI),
+        ACL_LINK
+    )
+
+    return Promise.resolve()
+        .then(() => {
+        if (aclDoc) {
+            return aclDoc as NamedNode
         }
 
-        return aclDoc
+        return fetchACLRel(docURI).catch(err => {
+            throw new Error(`Error fetching rel=ACL header for ${docURI}: ${err}`)
+        })
         })
-    })
-}
+        .then(aclDoc => {
+        const aclText = genACLText(docURI, me, aclDoc.uri, options)
+        if (!store.fetcher) {
+            throw new Error('Cannot PUT this, store has no fetcher')
+        }
+        return store.fetcher
+            .webOperation('PUT', aclDoc.uri, {
+            data: aclText,
+            contentType: 'text/turtle'
+            })
+            .then(result => {
+            if (!result.ok) {
+                throw new Error('Error writing ACL text: ' + result.error)
+            }
 
-/**
- * @param docURI
- * @returns
- */
-function fetchACLRel (docURI: string): Promise<NamedNode> {
-    const fetcher = solidLogicSingleton.store.fetcher
-    if (!fetcher) {
-        throw new Error('Cannot fetch ACL rel, store has no fetcher')
+            return aclDoc
+            })
+        })
     }
 
-    return fetcher.load(docURI).then(result => {
-        if (!result.ok) {
-        throw new Error('fetchACLRel: While loading:' + (result as any).error)
+    /**
+     * @param docURI
+     * @returns
+     */
+    function fetchACLRel (docURI: string): Promise<NamedNode> {
+        const fetcher = store.fetcher
+        if (!fetcher) {
+            throw new Error('Cannot fetch ACL rel, store has no fetcher')
         }
 
-        const aclDoc = solidLogicSingleton.store.any(
-        solidLogicSingleton.store.sym(docURI),
-        ACL_LINK
-        )
+        return fetcher.load(docURI).then(result => {
+            if (!result.ok) {
+            throw new Error('fetchACLRel: While loading:' + (result as any).error)
+            }
 
-        if (!aclDoc) {
-        throw new Error('fetchACLRel: No Link rel=ACL header for ' + docURI)
-        }
+            const aclDoc = store.any(
+            store.sym(docURI),
+            ACL_LINK
+            )
 
-        return aclDoc as NamedNode
-    })
-}
+            if (!aclDoc) {
+            throw new Error('fetchACLRel: No Link rel=ACL header for ' + docURI)
+            }
+
+            return aclDoc as NamedNode
+        })
+    }
 
-/**
- * @param docURI
- * @param me
- * @param aclURI
- * @param options
- *
- * @returns Serialized ACL
- */
-export function genACLText (
-docURI: string,
-me: NamedNode,
-aclURI: string,
-options: {
-    defaultForNew?: boolean,
-    public?: []
-} = {}
-): string | undefined {
-const optPublic = options.public || []
-const g = graph()
-const auth = Namespace('http://www.w3.org/ns/auth/acl#')
-let a = g.sym(`${aclURI}#a1`)
-const acl = g.sym(aclURI)
-const doc = g.sym(docURI)
-g.add(a, ns.rdf('type'), auth('Authorization'), acl)
-g.add(a, auth('accessTo'), doc, acl)
-if (options.defaultForNew) {
-    g.add(a, auth('default'), doc, acl)
-}
-g.add(a, auth('agent'), me, acl)
-g.add(a, auth('mode'), auth('Read'), acl)
-g.add(a, auth('mode'), auth('Write'), acl)
-g.add(a, auth('mode'), auth('Control'), acl)
+    /**
+     * @param docURI
+     * @param me
+     * @param aclURI
+     * @param options
+     *
+     * @returns Serialized ACL
+     */
+    function genACLText (
+    docURI: string,
+    me: NamedNode,
+    aclURI: string,
+    options: {
+            defaultForNew?: boolean,
+            public?: []
+        } = {}
+    ): string | undefined {
+        const optPublic = options.public || []
+        const g = graph()
+        const auth = Namespace('http://www.w3.org/ns/auth/acl#')
+        let a = g.sym(`${aclURI}#a1`)
+        const acl = g.sym(aclURI)
+        const doc = g.sym(docURI)
+        g.add(a, ns.rdf('type'), auth('Authorization'), acl)
+        g.add(a, auth('accessTo'), doc, acl)
+        if (options.defaultForNew) {
+            g.add(a, auth('default'), doc, acl)
+        }
+        g.add(a, auth('agent'), me, acl)
+        g.add(a, auth('mode'), auth('Read'), acl)
+        g.add(a, auth('mode'), auth('Write'), acl)
+        g.add(a, auth('mode'), auth('Control'), acl)
 
-if (optPublic.length) {
-    a = g.sym(`${aclURI}#a2`)
-    g.add(a, ns.rdf('type'), auth('Authorization'), acl)
-    g.add(a, auth('accessTo'), doc, acl)
-    g.add(a, auth('agentClass'), ns.foaf('Agent'), acl)
-    for (let p = 0; p < optPublic.length; p++) {
-    g.add(a, auth('mode'), auth(optPublic[p]), acl) // Like 'Read' etc
+        if (optPublic.length) {
+            a = g.sym(`${aclURI}#a2`)
+            g.add(a, ns.rdf('type'), auth('Authorization'), acl)
+            g.add(a, auth('accessTo'), doc, acl)
+            g.add(a, auth('agentClass'), ns.foaf('Agent'), acl)
+            for (let p = 0; p < optPublic.length; p++) {
+            g.add(a, auth('mode'), auth(optPublic[p]), acl) // Like 'Read' etc
+            }
+        }
+        return serialize(acl, g, aclURI)
+    }
+    return {
+        findAclDocUrl,
+        setACLUserPublic,
+        genACLText
     }
-}
-return serialize(acl, g, aclURI)
-}
+}

package/src/authn/SolidAuthnLogic.ts

@@ -3,22 +3,23 @@ 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; 
+  private session: Session;
 
   constructor(solidAuthSession: Session) {
     this.session = solidAuthSession;
   }
-  
+
   // we created authSession getter because we want to access it as authn.authSession externally
-  get authSession():Session { return this.session } 
+  get authSession():Session { return this.session }
 
   currentUser(): NamedNode | null {
     const app = appContext()
     if (app.viewingNoAuthPage) {
       return sym(app.webId)
     }
-    if (this.session.info.webId && this.session.info.isLoggedIn) {
+    if (this && this.session && this.session.info && this.session.info.webId && this.session.info.isLoggedIn) {
       return sym(this.session.info.webId)
     }
     return offlineTestID() // null unless testing
@@ -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
@@ -120,4 +121,4 @@ export class SolidAuthnLogic implements AuthnLogic {
     return webId
   }
 
-}
+}

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 } 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(ourInbox);
+      await utilityLogic.setSinglePeerAccess({
+        ownerWebId: myWebId.value,
+        peerWebId,
+        accessToModes: 'acl:Append',
+        target: ourInbox
+      });
+      return ourInbox;
+  }
+
+  async function getNewMessages(
+      user?: NamedNode
+    ): Promise<string[]> {
+      if (!user) {
+        user = await profileLogic.loadMe();
+      }
+      const inbox = await profileLogic.getMainInbox(user);
+      const urls = await containerLogic.getContainerMembers(inbox.value);
+      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'
   }
 ]