solid-logic 1.3.12-bbf45639 → 1.3.13-438dc3ae

package/src/index.ts

@@ -1,308 +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";
-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;
-  }
-}
+export {
+  setACLUserPublic,
+  genACLText
+} from './acl/aclLogic'
+export {
+  ensureTypeIndexes,
+  loadTypeIndexes,
+  registerInTypeIndex,
+  loadIndex
+} from './typeIndex/typeIndexLogic'
+export { default as 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'

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;
+    }
+}

package/src/logic/SolidLogic.ts

@@ -0,0 +1,264 @@
+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 { SolidAuthnLogic } from "../authn/SolidAuthnLogic";
+import { ChatLogic } from "../chat/ChatLogic";
+import { ProfileLogic } from "../profile/ProfileLogic";
+import { AuthnLogic, SolidNamespace } from "../types";
+import * as debug from "../util/debug";
+import { UtilityLogic } from "../util/UtilityLogic";
+import { CrossOriginForbiddenError, FetchError, NotFoundError, SameOriginForbiddenError, UnauthorizedError } from "./CustomError";
+
+
+const ns: SolidNamespace = solidNamespace(rdf);
+
+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 }, session: 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;
+        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.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);
+    }
+}

package/src/logic/solidLogicSingleton.ts

@@ -0,0 +1,24 @@
+import * as debug from "../util/debug"
+import authSession from "../authSession/authSession"
+import { SolidLogic } from "./SolidLogic"
+
+const fetcher = async (url, requestInit) => {
+    if (authSession.info.webId) {
+        return authSession.fetch(url, requestInit)
+    } else {
+        return window.fetch(url, requestInit)
+    }
+}
+
+const solidLogicSingleton = new SolidLogic({ fetch: fetcher }, authSession)
+
+// Make this directly accessible as it is what you need most of the time
+const authn = solidLogicSingleton.authn
+const store = solidLogicSingleton.store
+
+const chat = solidLogicSingleton.chat
+const profile = solidLogicSingleton.profile
+
+debug.log('Unique quadstore initialized.')
+
+export { solidLogicSingleton, authn, store, chat, profile }

package/src/profile/ProfileLogic.ts

@@ -1,6 +1,5 @@
-import { LiveStore, NamedNode } from "rdflib";
-import { AuthnLogic } from "../authn";
-import { SolidNamespace } from "../index";
+import { NamedNode, LiveStore } from "rdflib";
+import { AuthnLogic, SolidNamespace } from "../types";
 
 export class ProfileLogic {
   store: LiveStore;