solid-logic 1.3.13-ef4be651 → 1.3.13-f1b5b524

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";

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

package/src/index.ts

@@ -1,308 +1,29 @@
-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";
-import { ConnectedStore, LiveStore } from 'rdflib'
-
-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;
-  }
-}
+// 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 { 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

@@ -0,0 +1,40 @@
+const DEFAULT_ISSUERS = [
+  {
+    name: 'Solid Community',
+    uri: 'https://solidcommunity.net'
+  },
+  {
+    name: 'Solid Web',
+    uri: 'https://solidweb.org'
+  },
+  {
+    name: 'Inrupt.net',
+    uri: 'https://inrupt.net'
+  },
+  {
+    name: 'pod.Inrupt.com',
+    uri: 'https://broker.pod.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,25 @@
+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;
+    }
+}