solid-logic 1.3.17-f7bdc345 → 1.3.17-fca5749b

package/src/index.ts

@@ -1,52 +1,143 @@
 // 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
+const aclLogic = solidLogicSingleton.aclLogic
+const utilityLogic = solidLogicSingleton.utilityLogic
+const containerLogic = solidLogicSingleton.containerLogic
+const profileLogic = solidLogicSingleton.profileLogic
+const inboxLogic = solidLogicSingleton.inboxLogic
+const typeIndexLogic = solidLogicSingleton.typeIndexLogic
+const chatLogic = solidLogicSingleton.chatLogic
 
-export {
+const {
+  findAclDocUrl,
   setACLUserPublic,
-  genACLText
-} from './acl/aclLogic'
+  genACLText,
+} = aclLogic
 
-export {
-  ensureTypeIndexes,
-  loadTypeIndexes,
+const {
   registerInTypeIndex,
-  loadIndex
-} from './typeIndex/typeIndexLogic'
-
-// Generate by
-//  grep export src/discovery/discoveryLogic.ts | sed -e 's/export //g'  | sed -e 's/async //g'| sed -e 's/function //g' | sed -e 's/ .*/,/g' | sort
-export {
+  getRegistrations,
+  //NEW function for discovery
+  loadTypeIndexesFor,
+  loadCommunityTypeIndexes,
+  loadAllTypeIndexes,
+  getScopedAppInstances,
+  getAppInstances,
+  suggestPublicTypeIndex,
+  suggestPrivateTypeIndex,
   deleteTypeIndexRegistration,
+  getScopedAppsFromIndex
+} = typeIndexLogic
+
+const {
+  setAcl,
+  addToPrivateTypeIndex,
+  findChat,
+  createChatThing,
+  getChat,
+  sendInvite,
+  mintNew
+} = chatLogic
+
+const  { createInboxFor, getNewMessages, markAsRead } = inboxLogic
+const {
+  recursiveDelete,
+  setSinglePeerAccess,
+  createEmptyRdfDoc,
+  //NEW function for discovery
   followOrCreateLink,
-  getAppInstances,
-  getScopedAppInstances,
-  getScopedAppsFromIndex,
-  loadAllTypeIndexes,
-  loadCommunityTypeIndexes,
   loadOrCreateIfNotExists,
+} = utilityLogic
+
+const  {
+  loadMe,
+  getPodRoot,
+  getMainInbox,
+  findStorage,
+   //NEW content from discovery
   loadPreferences,
   loadProfile,
-  loadTypeIndexesFor,
-  registerInstanceInTypeIndex,
-  suggestPreferencesFile,
-  suggestPrivateTypeIndex,
-  suggestPublicTypeIndex,
-  uniqueNodes
-} from './discovery/discoveryLogic'
+  //NEW function for discovery
+  silencedLoadPreferences
+} = profileLogic
 
-export { SolidLogic } from './logic/SolidLogic'
+const {
+  isContainer,
+  createContainer,
+  getContainerElements,
+  getContainerMembers
+} = containerLogic
+
+export { ACL_LINK } from './acl/aclLogic'
 export { offlineTestID, appContext } from './authn/authUtil'
-export { ACL_LINK } from './util/UtilityLogic'
 export { getSuggestedIssuers } from './issuer/issuerLogic'
+export { SolidLogic } from './logic/SolidLogic'
 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 }
+export { UnauthorizedError, CrossOriginForbiddenError, SameOriginForbiddenError, NotFoundError, FetchError, NotEditableError, WebOperationError } from './logic/CustomError'
+
+export {
+  store,
+  authn,
+  authSession,
+  aclLogic,
+  utilityLogic,
+  containerLogic,
+  profileLogic,
+  inboxLogic,
+  typeIndexLogic,
+  chatLogic,
+  //aclLogic
+  findAclDocUrl,
+  setACLUserPublic,
+  genACLText,
+  //typeIndexLogic
+  registerInTypeIndex,
+  getRegistrations,
+  loadTypeIndexesFor,
+  loadCommunityTypeIndexes,
+  loadAllTypeIndexes,
+  getScopedAppInstances,
+  getAppInstances,
+  suggestPublicTypeIndex,
+  suggestPrivateTypeIndex,
+  deleteTypeIndexRegistration,
+  getScopedAppsFromIndex,
+  setAcl,
+  addToPrivateTypeIndex,
+  findChat,
+  createChatThing,
+  getChat,
+  sendInvite,
+  //inboxLogic
+  mintNew,
+  createInboxFor,
+  getNewMessages,
+  markAsRead,
+  //utilityLogic
+  recursiveDelete,
+  setSinglePeerAccess,
+  createEmptyRdfDoc,
+  followOrCreateLink,
+  loadOrCreateIfNotExists,
+  //profileLogic
+  loadMe,
+  getPodRoot,
+  getMainInbox,
+  findStorage,
+  loadPreferences,
+  loadProfile,
+  silencedLoadPreferences,
+  //containerLogic
+  isContainer,
+  createContainer,
+  getContainerElements,
+  getContainerMembers
+}

package/src/logic/CustomError.ts

@@ -6,7 +6,7 @@ class CustomError extends Error {
         this.name = new.target.name; // stack traces display correctly now
     }
 }
-    
+
 export class UnauthorizedError extends CustomError {}
 
 export class CrossOriginForbiddenError extends CustomError {}
@@ -15,6 +15,10 @@ 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;
 

package/src/logic/SolidLogic.ts

@@ -1,222 +1,64 @@
 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 { LiveStore, NamedNode, Statement } from "rdflib";
+import { createAclLogic } from "../acl/aclLogic";
 import { SolidAuthnLogic } from "../authn/SolidAuthnLogic";
-import { ChatLogic } from "../chat/ChatLogic";
-import { ProfileLogic } from "../profile/ProfileLogic";
-import { AuthnLogic, SolidNamespace } from "../types";
+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 } from "../types";
 import * as debug from "../util/debug";
-import { UtilityLogic } from "../util/UtilityLogic";
-import { CrossOriginForbiddenError, FetchError, NotFoundError, SameOriginForbiddenError, UnauthorizedError } from "./CustomError";
 /*
 ** 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`,
 */
-
-const ns: SolidNamespace = solidNamespace(rdf);
-
 export class SolidLogic {
-    cache: {
-        profileDocument: {
-        [WebID: string]: NamedNode;
-        };
-        preferencesFile: {
-        [WebID: string]: NamedNode;
-        };
-    };
 
     store: LiveStore;
     me: string | undefined;
-    chat: ChatLogic;
-    profile: ProfileLogic;
     authn: AuthnLogic;
-    util: UtilityLogic;
+
+    aclLogic
+    utilityLogic
+    containerLogic
+    profileLogic
+    inboxLogic
+    typeIndexLogic
+    chatLogic
+
 
     constructor(specialFetch: { fetch: (url: any, requestInit: any) => any }, session: Session) {
   // would xpect to be able to do it this way: but get TypeError:  Failed to execute 'fetch' on 'Window': Illegal invocation status: 999
         // this.store = new rdf.LiveStore({})
         // this.store.fetcher._fetch = fetch
-        console.log("SolidLogic: Unique instance created.  There should only be one of these.")
+        debug.log("SolidLogic: Unique instance created.  There should only be one of these.")
         this.store = rdf.graph() as LiveStore; // Make a Quad store
         rdf.fetcher(this.store, { fetch: specialFetch.fetch}); // Attach a web I/O module, store.fetcher
         this.store.updater = new rdf.UpdateManager(this.store); // Add real-time live updates store.updater
-
         this.store.features = [] // disable automatic node merging on store load
-        this.cache = {
-        profileDocument: {},
-        preferencesFile: {},
-        };
-        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);
-    }
-
-    findAclDocUrl(url: string) {
-        return this.util.findAclDocUrl(url);
-    }
+        
+        this.authn = new SolidAuthnLogic(session)
 
-    async loadProfile(me: NamedNode): Promise<NamedNode> {
-        /*
-      // console.log('loadProfile cache ', this.cache)
-        if (this.cache.profileDocument[me.value]) {
-        return this.cache.profileDocument[me.value];
-      }    @@ just use the cache in the store
-        */
-        console.log('loadProfile  me ', me)
-        const profileDocument = me.doc()
-        try {
-          await this.store.fetcher.load(profileDocument);
-          return profileDocument;
-        } catch (err) {
-        const message = `Cannot load profile ${profileDocument} : ${err}`;
-        throw new Error(message);
-        }
-    }
-
-    async loadPreferences(me: NamedNode): Promise<NamedNode> {
-        console.log('loadPreferences cache ', this.cache)
-        if (this.cache.preferencesFile[me.value]) {
-        return this.cache.preferencesFile[me.value];
-        }
-        await this.loadProfile(me) // Load pointer to pref file
-        const preferencesFile = this.store.any(me, ns.space('preferencesFile'), null, me.doc());
-
-        // 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()}`
-        );
-        }
-
-        // //// 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[];
-    }
+        debug.log('SolidAuthnLogic initialized')
 
-    getRegistrations(instance, theClass) {
-        return this.store
-        .each(undefined, ns.solid("instance"), instance)
-        .filter((r) => {
-            return this.store.holds(r, ns.solid("forClass"), theClass);
-        });
+        this.aclLogic = createAclLogic(this.store)
+        this.containerLogic = createContainerLogic(this.store)
+        this.utilityLogic = createUtilityLogic(this.store, this.aclLogic, this.containerLogic)
+        this.profileLogic = createProfileLogic(this.store, this.authn, this.utilityLogic)
+        this.chatLogic = createChatLogic(this.store, this.profileLogic)
+        this.inboxLogic = createInboxLogic(this.store, this.profileLogic, this.utilityLogic, this.containerLogic, this.aclLogic)
+        this.typeIndexLogic = createTypeIndexLogic(this.store, this.authn, this.profileLogic, this.utilityLogic)
     }
 
     load(doc: NamedNode | NamedNode[] | string) {
         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) {
-        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>,
@@ -233,27 +75,7 @@ export class SolidLogic {
         }); // 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.store.fetcher._fetch(url, options);
+        this.store.statements.slice().forEach(this.store.remove.bind(this.store));
     }
 }

package/src/logic/solidLogicSingleton.ts

@@ -5,7 +5,7 @@ import { SolidLogic } 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 ftech should respect crentials omit itself
+        // In fact fetch should respect credentials omit itself
         return authSession.fetch(url, requestInit)
     } else {
         return window.fetch(url, requestInit)

package/src/logic/solidLogicSingletonNew.ts

@@ -0,0 +1,210 @@
+import * as rdf from "rdflib"
+import { SolidAuthnLogic } from "../authn/SolidAuthnLogic"
+import { authSession } from "../authSession/authSession"
+import { createContainerLogic } from "../util/containerLogic"
+import { createTypeIndexLogic } from "../typeIndex/typeIndexLogic"
+import * as debug from "../util/debug"
+import { createUtilityLogic } from "../util/utilityLogic"
+import { createProfileLogic } from "../profile/profileLogic"
+import { createInboxLogic } from "../inbox/inboxLogic"
+import { createChatLogic } from "../chat/chatLogic"
+import { createAclLogic } from "../acl/aclLogic"
+
+export function solidLogicSingleton() {
+    
+    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)
+        }
+    }
+
+    debug.log("SolidLogicSingleton: Unique instance created.  There should only be one of these.")
+
+    const store = rdf.graph() as rdf.LiveStore; // Make a Quad store
+    rdf.fetcher(store, { fetch: _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
+
+    debug.log('SolidAuthnLogic initialized')
+    const authn = new SolidAuthnLogic(authSession)
+
+    const aclLogic = createAclLogic(store)
+    const {
+        findAclDocUrl,
+        setACLUserPublic,
+        genACLText
+    } = aclLogic
+
+    const containerLogic = createContainerLogic(store)
+    const {
+        isContainer,
+        createContainer,
+        getContainerElements,
+        getContainerMembers
+    } = containerLogic
+
+    const utilityLogic = createUtilityLogic(store, aclLogic, containerLogic)
+    const {
+        recursiveDelete,
+        setSinglePeerAccess,
+        createEmptyRdfDoc,
+        followOrCreateLink,
+        loadOrCreateIfNotExists
+    } = utilityLogic
+
+    const profileLogic = createProfileLogic(store, authn, utilityLogic)
+    const {
+        loadMe,
+        getPodRoot,
+        getMainInbox,
+        findStorage,
+        loadPreferences,
+        loadProfile,
+        silencedLoadPreferences
+    } = profileLogic
+
+    const chatLogic = createChatLogic(store, profileLogic)
+    const {
+        setAcl,
+        addToPrivateTypeIndex,
+        findChat,
+        createChatThing,
+        getChat,
+        sendInvite,
+        mintNew
+    } = chatLogic
+
+    const inboxLogic = createInboxLogic(store, profileLogic, utilityLogic, containerLogic, aclLogic)
+    const {
+        createInboxFor,
+        getNewMessages,
+        markAsRead
+    } = inboxLogic
+
+    const typeIndexLogic = createTypeIndexLogic(store, authn, profileLogic, utilityLogic)
+    const {
+        registerInTypeIndex,
+        getRegistrations,
+        loadTypeIndexesFor,
+        loadCommunityTypeIndexes,
+        loadAllTypeIndexes,
+        getScopedAppInstances,
+        getAppInstances,
+        suggestPublicTypeIndex,
+        suggestPrivateTypeIndex,
+        deleteTypeIndexRegistration,
+        getScopedAppsFromIndex
+    } = typeIndexLogic
+
+    return {
+        store,
+        authn,
+        authSession,
+        //unilityLogic
+        recursiveDelete,
+        setSinglePeerAccess,
+        createEmptyRdfDoc,
+        followOrCreateLink,
+        loadOrCreateIfNotExists,
+        //containerLogic
+        isContainer,
+        createContainer,
+        getContainerElements,
+        getContainerMembers,
+        //typeIndexLogic
+        registerInTypeIndex,
+        getRegistrations,
+        loadTypeIndexesFor,
+        loadCommunityTypeIndexes,
+        loadAllTypeIndexes,
+        getScopedAppInstances,
+        getAppInstances,
+        suggestPublicTypeIndex,
+        suggestPrivateTypeIndex,
+        deleteTypeIndexRegistration,
+        getScopedAppsFromIndex,
+        //profileLogic
+        loadMe,
+        getPodRoot,
+        getMainInbox,
+        findStorage,
+        loadPreferences,
+        loadProfile,
+        silencedLoadPreferences,
+        //inboxLogic
+        createInboxFor,
+        getNewMessages,
+        markAsRead,
+        //chatLogic
+        setAcl,
+        addToPrivateTypeIndex,
+        findChat,
+        createChatThing,
+        getChat,
+        sendInvite,
+        mintNew,
+        //aclLogic
+        findAclDocUrl,
+        setACLUserPublic,
+        genACLText
+    }
+}
+
+/*export {
+    store,
+    authn,
+    authSession,
+    //unilityLogic
+    recursiveDelete,
+    setSinglePeerAccess,
+    createEmptyRdfDoc,
+    followOrCreateLink,
+    loadOrCreateIfNotExists,
+    //containerLogic
+    isContainer,
+    createContainer,
+    getContainerElements,
+    getContainerMembers,
+    //typeIndexLogic
+    ensureTypeIndexes,
+    registerInTypeIndex,
+    getRegistrations,
+    loadTypeIndexesFor,
+    loadCommunityTypeIndexes,
+    loadAllTypeIndexes,
+    getScopedAppInstances,
+    getAppInstances,
+    suggestPublicTypeIndex,
+    suggestPrivateTypeIndex,
+    deleteTypeIndexRegistration,
+    getScopedAppsFromIndex,
+    //profileLogic
+    loadMe,
+    getPodRoot,
+    getMainInbox,
+    findStorage,
+    loadPreferences,
+    loadProfile,
+    silencedLoadPreferences,
+    //inboxLogic
+    createInboxFor,
+    getNewMessages,
+    markAsRead,
+    //chatLogic
+    setAcl,
+    addToPrivateTypeIndex,
+    findChat,
+    createChatThing,
+    getChat,
+    sendInvite,
+    mintNew,
+    //aclLogic
+    findAclDocUrl,
+    setACLUserPublic,
+    genACLText
+}
+*/