solid-logic 1.3.17-ec29db42 → 1.3.17-f02a2f1a

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 } 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,20 @@
 // 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 {
-  loadProfile,
-  loadPreferences,
-  loadTypeIndexesFor,
-  loadCommunityTypeIndexes,
-  loadAllTypeIndexes
-} from './discovery/discoveryLogic'
-
-export { SolidLogic } from './logic/SolidLogic'
+export { ACL_LINK } from './acl/aclLogic'
 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 }
+export { AppDetails, SolidNamespace, AuthenticationContext, SolidLogic } from './types'
+export { UnauthorizedError, CrossOriginForbiddenError, SameOriginForbiddenError, NotFoundError, FetchError, NotEditableError, WebOperationError } from './logic/CustomError'
+
+export {
+  solidLogicSingleton, // solidLogicSingleton is exported entirely because it is used in solid-panes
+  store,
+  authn,
+  authSession
+}

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

@@ -1,232 +1,52 @@
 import { Session } from "@inrupt/solid-client-authn-browser";
 import * as rdf from "rdflib";
-import { NamedNode, Statement, LiveStore } from "rdflib";
-import solidNamespace from "solid-namespace";
+import { LiveStore, NamedNode, Statement } from "rdflib";
+import { createAclLogic } from "../acl/aclLogic";
 import { SolidAuthnLogic } from "../authn/SolidAuthnLogic";
-import { ChatLogic } from "../chat/ChatLogic";
-import { ProfileLogic } from "../profile/ProfileLogic";
-import { AuthnLogic, SolidNamespace } from "../types";
+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";
-import { UtilityLogic } from "../util/UtilityLogic";
-import { CrossOriginForbiddenError, FetchError, NotFoundError, SameOriginForbiddenError, UnauthorizedError } from "./CustomError";
 /*
 ** 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 {
 
-const ns: SolidNamespace = solidNamespace(rdf);
+    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
 
-export class SolidLogic {
-    cache: {
-        profileDocument: {
-        [WebID: string]: NamedNode;
-        };
-        preferencesFile: {
-        [WebID: string]: NamedNode;
-        };
-    };
+    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')
 
-    store: LiveStore;
-    me: string | undefined;
-    underlyingFetch: { fetch: (url: string, options?: any) => any };
-
-    chat: ChatLogic;
-    profile: ProfileLogic;
-    authn: AuthnLogic;
-    util: UtilityLogic;
-
-    constructor(specialFetch: { fetch: (url: any, requestInit: any) => any }, session: Session) {
-  // would xpect to be able to do it this way: but get TypeError:  Failed to execute 'fetch' on 'Window': Illegal invocation status: 999
-        // this.store = new rdf.LiveStore({})
-        // this.store.fetcher._fetch = fetch
-        console.log("SolidLogic: Unique instance created.  There should only be one of these.")
-        this.store = rdf.graph() as LiveStore; // Make a Quad store
-        rdf.fetcher(this.store, { fetch: specialFetch.fetch}); // Attach a web I/O module, store.fetcher
-        this.store.updater = new rdf.UpdateManager(this.store); // Add real-time live updates store.updater
-
-        this.store.features = [] // disable automatic node merging on store load
-        this.cache = {
-        profileDocument: {},
-        preferencesFile: {},
-        };
-        this.underlyingFetch = { fetch: fetch }; // Note global one not the one passed
-        this.authn = new SolidAuthnLogic(session);
-        debug.log('SolidAuthnLogic initialized')
-        this.profile = new ProfileLogic(this.store, ns, this.authn);
-        this.chat = new ChatLogic(this.store, ns, this.profile);
-        this.util = new UtilityLogic(this.store, ns, this.underlyingFetch);
-    }
-
-    findAclDocUrl(url: string) {
-        return this.util.findAclDocUrl(url);
-    }
-
-    async loadProfile(me: NamedNode): Promise<NamedNode> {
-        /*
-      // console.log('loadProfile cache ', this.cache)
-        if (this.cache.profileDocument[me.value]) {
-        return this.cache.profileDocument[me.value];
-      }    @@ just use the cache in the store
-        */
-        console.log('loadProfile  me ', me)
-        const profileDocument = me.doc()
-        try {
-          await this.store.fetcher.load(profileDocument);
-          return profileDocument;
-        } catch (err) {
-        const message = `Cannot load profile ${profileDocument} : ${err}`;
-        throw new Error(message);
-        }
-    }
-
-    async loadPreferences(me: NamedNode): Promise<NamedNode> {
-        console.log('loadPreferences cache ', this.cache)
-        if (this.cache.preferencesFile[me.value]) {
-        return this.cache.preferencesFile[me.value];
-        }
-        await this.loadProfile(me) // Load pointer to pref file
-        const preferencesFile = this.store.any(me, ns.space('preferencesFile'), null, me.doc());
-
-        // console.log('this.store.any()', this.store.any())
-        /**
-         * Are we working cross-origin?
-         * Returns True if we are in a webapp at an origin, and the file origin is different
-         */
-        function differentOrigin(): boolean {
-        if (!preferencesFile) {
-            return true;
-        }
-        return (
-            `${window.location.origin}/` !== new URL(preferencesFile.value).origin
-        );
-        }
-
-        if (!preferencesFile) {
-        throw new Error(
-            `Can't find a preference file pointer in profile ${me.doc()}`
-        );
-        }
-
-        // //// Load preference file
-        try {
-        await this.store.fetcher.load(preferencesFile as NamedNode, {
-            withCredentials: true,
-        });
-        } catch (err) {
-        // Really important to look at why
-        const status = err.status;
-        debug.log(`HTTP status ${status} for preference file ${preferencesFile}`);
-        if (status === 401) {
-            throw new UnauthorizedError();
-        }
-        if (status === 403) {
-            if (differentOrigin()) {
-            throw new CrossOriginForbiddenError();
-            }
-            throw new SameOriginForbiddenError();
-        }
-        if (status === 404) {
-            throw new NotFoundError(preferencesFile.value);
-        }
-        throw new FetchError(err.status, err.message);
-        }
-        return preferencesFile as NamedNode;
-    }
-
-    getTypeIndex(
-        me: NamedNode | string,
-        preferencesFile: NamedNode | string,
-        isPublic: boolean
-    ): NamedNode[] {
-        // console.log('getTypeIndex', this.store.each(me, undefined, undefined, preferencesFile), isPublic, preferencesFile)
-        return this.store.each(
-        me as NamedNode,
-        isPublic ? ns.solid("publicTypeIndex") : ns.solid("privateTypeIndex"),
-        undefined,
-        preferencesFile as NamedNode
-        ) as NamedNode[];
-    }
-
-    getRegistrations(instance, theClass) {
-        return this.store
-        .each(undefined, ns.solid("instance"), instance)
-        .filter((r) => {
-            return this.store.holds(r, ns.solid("forClass"), theClass);
-        });
-    }
-
-    load(doc: NamedNode | NamedNode[] | string) {
-        return this.store.fetcher.load(doc);
-    }
-
-    async loadIndexes(
-        me: NamedNode | string,
-        publicProfile: NamedNode | string | null,
-        preferencesFile: NamedNode | string | null,
-        onWarning = async (_err: Error) => {
-            return undefined;
-        }
-    ): Promise<{
-        private: any;
-        public: any;
-    }> {
-        let privateIndexes: any[] = [];
-        let publicIndexes: any[] = [];
-        if (publicProfile) {
-        publicIndexes = this.getTypeIndex(me, publicProfile, true);
-        try {
-            await this.load(publicIndexes as NamedNode[]);
-        } catch (err) {
-            onWarning(new Error(`loadIndex: loading public type index(es) ${err}`));
-        }
-        }
-        if (preferencesFile) {
-        privateIndexes = this.getTypeIndex(me, preferencesFile, false);
-        // console.log({ privateIndexes })
-        if (privateIndexes.length === 0) {
-            await onWarning(
-            new Error(
-                `Your preference file ${preferencesFile} does not point to a private type index.`
-            )
-            );
-        } else {
-            try {
-            await this.load(privateIndexes);
-            } catch (err) {
-            onWarning(
-                new Error(`loadIndex: loading private type index(es) ${err}`)
-            );
-            }
-        }
-        // } else {
-        //   debug.log(
-        //     'We know your preference file is not available, so we are not bothering with private type indexes.'
-        //   )
-        }
-
-        return {
-        private: privateIndexes,
-        public: publicIndexes,
-        };
-    }
-
-    async createEmptyRdfDoc(doc: NamedNode, comment: string) {
-        await this.store.fetcher.webOperation("PUT", doc.uri, {
-        data: `# ${new Date()} ${comment}
-    `,
-        contentType: "text/turtle",
-        });
+    function load(doc: NamedNode | NamedNode[] | string) {
+        return store.fetcher.load(doc);
     }
 
     // @@@@ use the one in rdflib.js when it is available and delete this
-    updatePromise(
+    function updatePromise(
         del: Array<Statement>,
         ins: Array<Statement> = []
     ): Promise<void> {
         return new Promise((resolve, reject) => {
-        this.store.updater.update(del, ins, function (_uri, ok, errorBody) {
+        store.updater.update(del, ins, function (_uri, ok, errorBody) {
             if (!ok) {
             reject(new Error(errorBody));
             } else {
@@ -236,27 +56,20 @@ export class SolidLogic {
         }); // promise
     }
 
-    isContainer(url: string) {
-        return this.util.isContainer(url);
-    }
-
-    getContainerElements(containerNode: NamedNode): NamedNode[] {
-        return this.util.getContainerElements(containerNode);
-    }
-
-    getContainerMembers(containerUrl: string): Promise<string[]> {
-        return this.util.getContainerMembers(containerUrl);
-    }
-
-    async recursiveDelete(url: string) {
-        return this.util.recursiveDelete(url);
-    }
-
-    clearStore() {
-        return this.util.clearStore();
+    function clearStore() {
+        store.statements.slice().forEach(store.remove.bind(store));
     }
 
-    async fetch(url: string, options?: any) {
-        return this.underlyingFetch.fetch(url, options);
+    return {
+        store,
+        authn,
+        acl,
+        inbox,
+        chat,
+        profile,
+        typeIndex,
+        load,
+        updatePromise,
+        clearStore
     }
 }