solid-logic 1.3.13 → 1.3.14-e8adc14a

package/src/acl/aclLogic.ts

@@ -0,0 +1,137 @@
+/**
+ * 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 } 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 function setACLUserPublic ( 
+docURI: string,
+me: NamedNode,
+options: {
+    defaultForNew?: boolean,
+    public?: []
+}
+): Promise<NamedNode> {
+const aclDoc = solidLogicSingleton.store.any(
+    solidLogicSingleton.store.sym(docURI),
+    ACL_LINK
+)
+
+return Promise.resolve()
+    .then(() => {
+    if (aclDoc) {
+        return aclDoc as NamedNode
+    }
+
+    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')
+    }
+    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)
+        }
+
+        return aclDoc
+        })
+    })
+}
+
+/**
+ * @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 fetcher.load(docURI).then(result => {
+        if (!result.ok) {
+        throw new Error('fetchACLRel: While loading:' + (result as any).error)
+        }
+
+        const aclDoc = solidLogicSingleton.store.any(
+        solidLogicSingleton.store.sym(docURI),
+        ACL_LINK
+        )
+
+        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)
+
+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)
+}

package/src/authSession/authSession.ts

@@ -0,0 +1,13 @@
+import {
+  Session,
+  getClientAuthenticationWithDependencies
+} from '@inrupt/solid-client-authn-browser'
+
+export const authSession = new Session(
+    {
+      clientAuthentication: getClientAuthenticationWithDependencies({})
+    },
+    'mySession'
+  )
+
+  

package/src/authn/SolidAuthnLogic.ts

@@ -1,18 +1,123 @@
-import { NamedNode, sym } from "rdflib";
-import { AuthnLogic } from "./index";
+import { namedNode, NamedNode, sym } from "rdflib";
+import { appContext, offlineTestID } from "./authUtil";
+import * as debug from '../util/debug'
 import { Session } from "@inrupt/solid-client-authn-browser";
-
-/**
- * Implements AuthnLogic relying on solid-auth-client
- */
+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 } 
 
   currentUser(): NamedNode | null {
-    return this.session?.info.webId ? sym(this.session.info.webId) : null;
+    const app = appContext()
+    if (app.viewingNoAuthPage) {
+      return sym(app.webId)
+    }
+    if (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.onSessionRestore((url) => {
+      if (document.location.toString() !== url) history.replaceState(null, '', url)
+    })
+
+    /**
+     * Handle a successful authentication redirect
+     */
+    await this.session
+      .handleIncomingRedirect({
+        restorePreviousSession: true,
+        url: window.location.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) {
+          // console.log('Setting window.location.has using pushState')
+          history.pushState(null, document.title, postLoginRedirectHash)
+        } else {
+          // console.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,67 @@
+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
+ */
+export const appContext = ():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 {
+    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/solid/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

@@ -1,7 +1,7 @@
-import { LiveStore, NamedNode, Node, st, term } from "rdflib";
-import { SolidNamespace } from "../index";
+import { NamedNode, Node, st, term, LiveStore } from "rdflib";
 import { ProfileLogic } from "../profile/ProfileLogic";
-import { newThing } from "../uri";
+import { SolidNamespace } from "../types";
+import { newThing } from "../util/uri";
 import { determineChatContainer } from "./determineChatContainer";
 
 const CHAT_LOCATION_IN_CONTAINER = "index.ttl#this";
@@ -225,7 +225,7 @@ export class ChatLogic {
     }
     const inviteBody = `
 <> a <http://www.w3.org/ns/pim/meeting#LongChatInvite> ;
-${this.ns.rdf("seeAlso")} <${chatThing.value}> . 
+${this.ns.rdf("seeAlso")} <${chatThing.value}> .
   `;
 
     const inviteResponse = await this.store.fetcher?.webOperation(

package/src/inbox/InboxLogic.ts

@@ -1,19 +1,7 @@
-// import { v4 as uuid } from "uuid";
-import { LiveStore, NamedNode, Node, st, term } from "rdflib";
-import { SolidNamespace } from "../index";
+import { NamedNode, LiveStore } from "rdflib";
 import { ProfileLogic } from "../profile/ProfileLogic";
+import { SolidNamespace } from "../types";
 import { UtilityLogic } from "../util/UtilityLogic";
-// import { newThing } from "../uri";
-
-interface NewPaneOptions {
-  me?: NamedNode;
-  newInstance?: NamedNode;
-  newBase: string;
-}
-
-interface CreatedPaneOptions {
-  newInstance: NamedNode;
-}
 
 /**
  * Inbox-related logic