solid-logic 1.3.12 → 1.3.13-33f4d6e3

package/src/authSession/authSession.ts

@@ -0,0 +1,12 @@
+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,120 @@
-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
- */
-export class SolidAuthnLogic implements AuthnLogic {
-  private session?: Session;
+import { AuthenticationContext } from "../types";
+export class SolidAuthnLogic {
+  private session: Session;
 
   constructor(solidAuthSession: Session) {
     this.session = solidAuthSession;
   }
 
   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 { NamedNode, Node, st, term } from "rdflib";
-import { LiveStore, 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";
@@ -38,7 +38,7 @@ export class ChatLogic {
     // 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 this.store.fetcher.load(chatContainer);
+    await this.store.fetcher?.load(chatContainer);
 
     // FIXME: check the Why value on this quad:
     const chatAclDoc = this.store.any(
@@ -66,7 +66,7 @@ export class ChatLogic {
     acl:mode
         acl:Read, acl:Append.
 `;
-    await this.store.fetcher.webOperation("PUT", chatAclDoc.value, {
+    await this.store.fetcher?.webOperation("PUT", chatAclDoc.value, {
       data: aclBody,
       contentType: "text/turtle",
     });
@@ -81,7 +81,7 @@ export class ChatLogic {
     if (!privateTypeIndex) {
       throw new Error("Private type index not found!");
     }
-    await this.store.fetcher.load(privateTypeIndex);
+    await this.store.fetcher?.load(privateTypeIndex);
     const reg = newThing(privateTypeIndex);
     const ins = [
       st(
@@ -99,7 +99,7 @@ export class ChatLogic {
       st(reg, this.ns.solid("instance"), chatThing, privateTypeIndex.doc()),
     ];
     await new Promise((resolve, reject) => {
-      this.store.updater.update([], ins, function (_uri, ok, errm) {
+      this.store.updater?.update([], ins, function (_uri, ok, errm) {
         if (!ok) {
           reject(new Error(errm));
         } else {
@@ -115,7 +115,7 @@ export class ChatLogic {
     const chatContainer = determineChatContainer(invitee, podRoot);
     let exists = true;
     try {
-      await this.store.fetcher.load(
+      await this.store.fetcher?.load(
         new NamedNode(chatContainer.value + "index.ttl#this")
       );
     } catch (e) {
@@ -165,7 +165,7 @@ export class ChatLogic {
     }
 
     return new Promise(function (resolve, reject) {
-      updater.put(
+      updater?.put(
         newChatDoc,
         kb.statementsMatching(undefined, undefined, undefined, newChatDoc),
         "text/turtle",
@@ -213,7 +213,7 @@ export class ChatLogic {
   }
 
   private async sendInvite(invitee: NamedNode, chatThing: NamedNode) {
-    await this.store.fetcher.load(invitee.doc());
+    await this.store.fetcher?.load(invitee.doc());
     const inviteeInbox = this.store.any(
       invitee,
       this.ns.ldp("inbox"),
@@ -228,7 +228,7 @@ export class ChatLogic {
 ${this.ns.rdf("seeAlso")} <${chatThing.value}> . 
   `;
 
-    const inviteResponse = await this.store.fetcher.webOperation(
+    const inviteResponse = await this.store.fetcher?.webOperation(
       "POST",
       inviteeInbox.value,
       {
@@ -236,9 +236,9 @@ ${this.ns.rdf("seeAlso")} <${chatThing.value}> .
         contentType: "text/turtle",
       }
     );
-    const locationStr = inviteResponse.headers.get("location");
+    const locationStr = inviteResponse?.headers.get("location");
     if (!locationStr) {
-      throw new Error(`Invite sending returned a ${inviteResponse.status}`);
+      throw new Error(`Invite sending returned a ${inviteResponse?.status}`);
     }
   }
 }

package/src/inbox/InboxLogic.ts

@@ -1,19 +1,7 @@
-// import { v4 as uuid } from "uuid";
-import { NamedNode, Node, st, term } from "rdflib";
-import { LiveStore, 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
@@ -70,7 +58,7 @@ export class InboxLogic {
     };
     const uploaded = await this.util.fetcher.fetch(archiveUrl, options);
     if (uploaded.status.toString()[0] === '2') {
-      await this.store.fetcher._fetch(url, {
+      await this.store.fetcher?._fetch(url, {
         method: 'DELETE'
       });
     }

package/src/index.ts

@@ -1,307 +1,18 @@
-import { Session } from "@inrupt/solid-client-authn-browser";
-import * as rdf from "rdflib";
-import { Fetcher, NamedNode, Statement, Store, UpdateManager } from "rdflib";
-import solidNamespace from "solid-namespace";
-import { AuthnLogic } from "./authn";
-import { NoAuthnLogic } from "./authn/NoAuthnLogic";
-import { SolidAuthnLogic } from "./authn/SolidAuthnLogic";
-
-import { ChatLogic } from "./chat/ChatLogic";
-import * as debug from "./debug";
-import { ProfileLogic } from "./profile/ProfileLogic";
-import { UtilityLogic } from "./util/UtilityLogic";
-
-export { ACL_LINK } from './util/UtilityLogic';
-
-const ns: SolidNamespace = solidNamespace(rdf);
-
-interface ConnectedStore extends Store {
-  fetcher: Fetcher;
-}
-
-export interface LiveStore extends ConnectedStore {
-  updater: UpdateManager;
-}
-
-export interface SolidNamespace {
-  [key: string]: (term: string) => NamedNode;
-}
-
-export class SolidLogic {
-  cache: {
-    profileDocument: {
-      [WebID: string]: NamedNode;
-    };
-    preferencesFile: {
-      [WebID: string]: NamedNode;
-    };
-  };
-
-  store: LiveStore;
-  me: string | undefined;
-  fetcher: { fetch: (url: string, options?: any) => any };
-
-  chat: ChatLogic;
-  profile: ProfileLogic;
-  authn: AuthnLogic;
-  util: UtilityLogic;
-
-  constructor(fetcher: { fetch: (url: any, requestInit: any) => any }, solidAuthSession: Session) {
-    this.store = rdf.graph() as LiveStore; // Make a Quad store
-    rdf.fetcher(this.store, fetcher); // Attach a web I/O module, store.fetcher
-    this.store.updater = new rdf.UpdateManager(this.store); // Add real-time live updates store.updater
-    this.cache = {
-      profileDocument: {},
-      preferencesFile: {},
-    };
-    this.fetcher = fetcher;
-    if (solidAuthSession) {
-      this.authn = new SolidAuthnLogic(solidAuthSession);
-    } else {
-      this.authn = new NoAuthnLogic();
-    }
-    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.fetcher);
-  }
-
-  findAclDocUrl(url: string) {
-    return this.util.findAclDocUrl(url);
-  }
-
-  loadDoc(doc: NamedNode): Promise<void> {
-    return this.util.loadDoc(doc);
-  }
-
-  async loadProfile(me: NamedNode): Promise<NamedNode> {
-    // console.log('loadProfile', me)
-    if (this.cache.profileDocument[me.value]) {
-      return this.cache.profileDocument[me.value];
-    }
-    let profileDocument;
-    try {
-      profileDocument = me.doc();
-      await this.loadDoc(profileDocument);
-      return profileDocument;
-    } catch (err) {
-      const message = `Logged in but cannot load profile ${profileDocument} : ${err}`;
-      throw new Error(message);
-    }
-  }
-
-  async loadPreferences(me: NamedNode): Promise<NamedNode> {
-    // console.log('loadPreferences', me)
-    if (this.cache.preferencesFile[me.value]) {
-      return this.cache.preferencesFile[me.value];
-    }
-    const preferencesFile = this.store.any(me, ns.space("preferencesFile"));
-
-    // 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()}`
-      );
-    }
-
-    if (!this.store.fetcher) {
-      throw new Error("Cannot load doc, have no fetcher");
-    }
-    // //// 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) {
-    if (!this.store.fetcher) {
-      throw new Error("Cannot load doc(s), have no fetcher");
-    }
-    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) {
-    if (!this.store.fetcher) {
-      throw new Error("Cannot create empty rdf doc, have no fetcher");
-    }
-    await this.store.fetcher.webOperation("PUT", doc.uri, {
-      data: `# ${new Date()} ${comment}
-`,
-      contentType: "text/turtle",
-    });
-  }
-
-  // @@@@ use the one in rdflib.js when it is available and delete this
-  updatePromise(
-    del: Array<Statement>,
-    ins: Array<Statement> = []
-  ): Promise<void> {
-    return new Promise((resolve, reject) => {
-      if (!this.store.updater) {
-        throw new Error("Cannot updatePromise, have no updater");
-      }
-      this.store.updater.update(del, ins, function (_uri, ok, errorBody) {
-        if (!ok) {
-          reject(new Error(errorBody));
-        } else {
-          resolve();
-        }
-      }); // callback
-    }); // 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();
-  }
-
-  async fetch(url: string, options?: any) {
-    return this.fetcher.fetch(url, options);
-  }
-}
-
-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 FetchError extends CustomError {
-  status: number;
-
-  constructor(status: number, message?: string) {
-    super(message);
-    this.status = status;
-  }
-}
+export {
+  setACLUserPublic,
+  genACLText
+} from './acl/aclLogic'
+export {
+  ensureTypeIndexes,
+  loadTypeIndexes,
+  registerInTypeIndex,
+  loadIndex
+} from './typeIndex/typeIndexLogic'
+export { authSession } from './authSession/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'
+export { solidLogicSingleton, authn, store, chat, profile } from './logic/solidLogicSingleton'
+export { UnauthorizedError, CrossOriginForbiddenError, SameOriginForbiddenError, NotFoundError, FetchError } from './logic/CustomError'