solid-logic 3.1.1-da65b2c → 3.1.1-e3eba68

package/src/authn/SolidAuthnLogic.ts

@@ -0,0 +1,127 @@
+import { namedNode, NamedNode, sym } from "rdflib";
+import { appContext, offlineTestID } from "./authUtil";
+import * as debug from '../util/debug'
+import { EVENTS, Session } from "@inrupt/solid-client-authn-browser";
+import { AuthenticationContext, AuthnLogic } from "../types";
+
+export class SolidAuthnLogic implements AuthnLogic {
+  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 }
+
+  currentUser(): NamedNode | null {
+    const app = appContext()
+    if (app.viewingNoAuthPage) {
+      return sym(app.webId)
+    }
+    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
+  }
+
+  /**
+   * Retrieves currently logged in webId from either
+   * defaultTestUser or SolidAuth
+   * Also activates a session after login
+   * @param [setUserCallback] Optional callback
+   * @returns Resolves with webId uri, if no callback provided
+   */
+  async checkUser<T> (
+    setUserCallback?: (me: NamedNode | null) => T
+  ): Promise<NamedNode | T | null> {
+    // Save hash for "restorePreviousSession"
+    const preLoginRedirectHash = new URL(window.location.href).hash
+    if (preLoginRedirectHash) {
+      window.localStorage.setItem('preLoginRedirectHash', preLoginRedirectHash)
+    }
+    this.session.events.on(EVENTS.SESSION_RESTORED, (url) => {
+      debug.log(`Session restored to ${url}`)
+      if (document.location.toString() !== url) history.replaceState(null, '', url)
+    })
+
+    /**
+     * Handle a successful authentication redirect
+     */
+    const redirectUrl = new URL(window.location.href)
+    redirectUrl.hash = ''
+    await this.session
+      .handleIncomingRedirect({
+        restorePreviousSession: true,
+        url: redirectUrl.href
+      })
+
+    // Check to see if a hash was stored in local storage
+    const postLoginRedirectHash = window.localStorage.getItem('preLoginRedirectHash')
+    if (postLoginRedirectHash) {
+      const curUrl = new URL(window.location.href)
+      if (curUrl.hash !== postLoginRedirectHash) {
+        if (history.pushState) {
+          // debug.log('Setting window.location.has using pushState')
+          history.pushState(null, document.title, postLoginRedirectHash)
+        } else {
+          // debug.warn('Setting window.location.has using location.hash')
+          location.hash = postLoginRedirectHash
+        }
+        curUrl.hash = postLoginRedirectHash
+      }
+      // See https://stackoverflow.com/questions/3870057/how-can-i-update-window-location-hash-without-jumping-the-document
+      // window.location.href = curUrl.toString()// @@ See https://developer.mozilla.org/en-US/docs/Web/API/Window/location
+      window.localStorage.setItem('preLoginRedirectHash', '')
+    }
+
+    // Check to see if already logged in / have the WebID
+    let me = offlineTestID()
+    if (me) {
+      return Promise.resolve(setUserCallback ? setUserCallback(me) : me)
+    }
+
+    const webId = this.webIdFromSession(this.session.info)
+    if (webId) {
+      me = this.saveUser(webId)
+    }
+
+    if (me) {
+      debug.log(`(Logged in as ${me} by authentication)`)
+    }
+
+    return Promise.resolve(setUserCallback ? setUserCallback(me) : me)
+  }
+
+  /**
+   * Saves `webId` in `context.me`
+   * @param webId
+   * @param context
+   *
+   * @returns Returns the WebID, after setting it
+   */
+  saveUser (
+    webId: NamedNode | string | null,
+    context?: AuthenticationContext
+  ): NamedNode | null {
+    let webIdUri: string
+    if (webId) {
+      webIdUri = (typeof webId === 'string') ? webId : webId.uri
+      const me = namedNode(webIdUri)
+      if (context) {
+        context.me = me
+      }
+      return me
+    }
+    return null
+  }
+
+  /**
+   * @returns {Promise<string|null>} Resolves with WebID URI or null
+   */
+  webIdFromSession (session?: { webId?: string, isLoggedIn: boolean }): string | null {
+    const webId = session?.webId && session.isLoggedIn ? session.webId : null
+    return webId
+  }
+
+}

package/src/authn/authUtil.ts

@@ -0,0 +1,70 @@
+import { NamedNode, sym } from "rdflib"
+import * as debug from '../util/debug'
+
+/**
+ * find a user or app's context as set in window.SolidAppContext
+ * this is a const, not a function, because we have problems to jest mock it otherwise
+ * see: https://github.com/facebook/jest/issues/936#issuecomment-545080082 for more
+ * @return {any} - an appContext object
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const appContext = ():any => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let { SolidAppContext }: any = window
+    SolidAppContext ||= {}
+    SolidAppContext.viewingNoAuthPage = false
+    if (SolidAppContext.noAuth && window.document) {
+        const currentPage = window.document.location.href
+        if (currentPage.startsWith(SolidAppContext.noAuth)) {
+        SolidAppContext.viewingNoAuthPage = true
+        const params = new URLSearchParams(window.document.location.search)
+        if (params) {
+            let viewedPage = SolidAppContext.viewedPage = params.get('uri') || null
+            if (viewedPage) {
+            viewedPage = decodeURI(viewedPage)
+            if (!viewedPage.startsWith(SolidAppContext.noAuth)) {
+                const ary = viewedPage.split(/\//)
+                SolidAppContext.idp = ary[0] + '//' + ary[2]
+                SolidAppContext.viewingNoAuthPage = false
+            }
+            }
+        }
+        }
+    }
+    return SolidAppContext
+}
+
+/**
+ * Returns `sym($SolidTestEnvironment.username)` if
+ * `$SolidTestEnvironment.username` is defined as a global
+ * or 
+ * returns testID defined in the HTML page
+ * @returns {NamedNode|null}
+ */
+export function offlineTestID (): NamedNode | null {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any 
+    const { $SolidTestEnvironment }: any = window
+    if (
+      typeof $SolidTestEnvironment !== 'undefined' &&
+      $SolidTestEnvironment.username
+    ) {
+      // Test setup
+      debug.log('Assuming the user is ' + $SolidTestEnvironment.username)
+      return sym($SolidTestEnvironment.username)
+    }
+    // hack that makes SolidOS work in offline mode by adding the webId directly in html
+    // example usage: https://github.com/solidos/mashlib/blob/29b8b53c46bf02e0e219f0bacd51b0e9951001dd/test/contact/local.html#L37
+    if (
+      typeof document !== 'undefined' &&
+      document.location &&
+      ('' + document.location).slice(0, 16) === 'http://localhost'
+    ) {
+      const div = document.getElementById('appTarget')
+      if (!div) return null
+      const id = div.getAttribute('testID')
+      if (!id) return null
+      debug.log('Assuming user is ' + id)
+      return sym(id)
+    }
+    return null
+}

package/src/chat/chatLogic.ts

@@ -0,0 +1,226 @@
+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")
+            );
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        } 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,59 @@
+import { NamedNode } from "rdflib";
+import { InboxLogic } from "../types";
+import { getArchiveUrl } from "../util/utils";
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+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<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

@@ -0,0 +1,22 @@
+// 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
+
+export { ACL_LINK } from './acl/aclLogic'
+export { offlineTestID, appContext } from './authn/authUtil'
+export { getSuggestedIssuers } from './issuer/issuerLogic'
+export { createTypeIndexLogic } from './typeIndex/typeIndexLogic'
+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/issuer/issuerLogic.ts

@@ -0,0 +1,40 @@
+const DEFAULT_ISSUERS = [
+  {
+    name: 'Solid Community',
+    uri: 'https://solidcommunity.net'
+  },
+  {
+    name: 'Solid Web',
+    uri: 'https://solidweb.org'
+  },
+  {
+    name: 'Solid Web ME',
+    uri: 'https://solidweb.me'
+  },
+  {
+    name: 'Inrupt.com',
+    uri: 'https://login.inrupt.com'
+  }
+]
+
+/**
+ * @returns - A list of suggested OIDC issuers
+ */
+export function getSuggestedIssuers (): { name: string, uri: string }[] {
+    // Suggest a default list of OIDC issuers
+    const issuers = [...DEFAULT_ISSUERS]
+  
+    // Suggest the current host if not already included
+    const { host, origin } = new URL(location.href)
+    const hosts = issuers.map(({ uri }) => new URL(uri).host)
+    if (!hosts.includes(host) && !hosts.some(existing => isSubdomainOf(host, existing))) {
+      issuers.unshift({ name: host, uri: origin })
+    }
+  
+    return issuers
+  }
+  
+function isSubdomainOf (subdomain: string, domain: string): boolean {
+    const dot = subdomain.length - domain.length - 1
+    return dot > 0 && subdomain[dot] === '.' && subdomain.endsWith(domain)
+}

package/src/logic/CustomError.ts

@@ -0,0 +1,29 @@
+class CustomError extends Error {
+    constructor(message?: string) {
+        super(message);
+        // see: typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html
+        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
+        this.name = new.target.name; // stack traces display correctly now
+    }
+}
+
+export class UnauthorizedError extends CustomError {}
+
+export class CrossOriginForbiddenError extends CustomError {}
+
+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;
+
+    constructor(status: number, message?: string) {
+        super(message);
+        this.status = status;
+    }
+}

package/src/logic/solidLogic.ts

@@ -0,0 +1,76 @@
+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`,
+*/
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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

@@ -0,0 +1,20 @@
+import * as debug from "../util/debug"
+import { authSession } from "../authSession/authSession"
+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 fetch should respect credentials omit itself
+        return authSession.fetch(url, requestInit)
+    } else {
+        return window.fetch(url, requestInit)
+    }
+}
+
+//this const makes solidLogicSingleton global accessible in mashlib
+const solidLogicSingleton = createSolidLogic({ fetch: _fetch }, authSession)
+
+debug.log('Unique quadstore initialized.')
+
+export { solidLogicSingleton }