solid-logic 1.3.17-1274f5aa → 1.3.17-1aa535b3

package/src/inbox/inboxLogic.ts

@@ -0,0 +1,57 @@
+import { NamedNode } from "rdflib";
+import { getArchiveUrl } from "../util/utils";
+
+export function createInboxLogic(store, profileLogic, utilityLogic, containerLogic, aclLogic) {
+  
+    async function createInboxFor(peerWebId: string, nick: string) {
+      const myWebId: NamedNode = await profileLogic.loadMe();
+      const podRoot: NamedNode = await profileLogic.getPodRoot(myWebId);
+      const ourInbox = `${podRoot.value}p2p-inboxes/${encodeURIComponent(nick)}/`;
+      await containerLogic.createContainer(ourInbox);
+      const aclDocUrl = await aclLogic.findAclDocUrl(ourInbox);
+      await utilityLogic.setSinglePeerAccess({
+        ownerWebId: myWebId.value,
+        peerWebId,
+        accessToModes: 'acl:Append',
+        target: ourInbox
+      });
+      return ourInbox;
+  }
+
+  async function getNewMessages(
+      user?: NamedNode
+    ): Promise<string[]> {
+      if (!user) {
+        user = await profileLogic.loadMe();
+      }
+      const inbox = await profileLogic.getMainInbox(user);
+      const urls = await containerLogic.getContainerMembers(inbox.value);
+      return urls.filter(url => !containerLogic.isContainer(url));
+  }
+
+  async function markAsRead(url: string, date: Date) {
+    const downloaded = await store.fetcher._fetch(url);
+    if (downloaded.status !== 200) {
+      throw new Error(`Not OK! ${url}`);
+    }
+    const archiveUrl = getArchiveUrl(url, date);
+    const options = {
+      method: 'PUT',
+      body: await downloaded.text(),
+      headers: [
+        ['Content-Type', downloaded.headers.get('Content-Type') || 'application/octet-stream']
+      ]
+    };
+    const uploaded = await store.fetcher._fetch(archiveUrl, options);
+    if (uploaded.status.toString()[0] === '2') {
+      await store.fetcher._fetch(url, {
+        method: 'DELETE'
+      });
+    }
+  }
+  return {
+    createInboxFor,
+    getNewMessages,
+    markAsRead
+  }
+}

package/src/index.ts

@@ -1,52 +1,92 @@
 // 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
+//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 {
+  ACL_LINK
+} from './acl/aclLogic'
 
 export {
+  findAclDocUrl,
   setACLUserPublic,
-  genACLText
-} from './acl/aclLogic'
+  genACLText,
+} from './logic/solidLogicSingleton'
 
 export {
   ensureTypeIndexes,
   loadTypeIndexes,
   registerInTypeIndex,
-  loadIndex
-} from './typeIndex/typeIndexLogic'
+  loadIndex,
+  ensureOneTypeIndex,
+  putIndex,
+  makeIndexIfNecessary,
+  loadIndexes,
+  getTypeIndex,
+  getRegistrations,
+  //NEW function for discovery
+  loadTypeIndexesFor,
+  loadCommunityTypeIndexes,
+  loadAllTypeIndexes,
+  getScopedAppInstances,
+  getAppInstances,
+  suggestPublicTypeIndex,
+  suggestPrivateTypeIndex,
+  registerInstanceInTypeIndex,
+  deleteTypeIndexRegistration,
+  getScopedAppsFromIndex
+} from './logic/solidLogicSingleton'
 
-// 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 {
-  deleteTypeIndexRegistration,
+  setAcl,
+  addToPrivateTypeIndex,
+  findChat,
+  createChatThing,
+  getChat,
+  sendInvite,
+  mintNew
+} from './logic/solidLogicSingleton'
+
+export { offlineTestID, appContext } from './authn/authUtil'
+export { createInboxFor, getNewMessages, markAsRead } from './logic/solidLogicSingleton'
+export {
+  recursiveDelete,
+  setSinglePeerAccess,
+  createEmptyRdfDoc,
+  //NEW function for discovery
   followOrCreateLink,
-  getAppInstances,
-  getScopedAppInstances,
-  getScopedAppsFromIndex,
-  loadAllTypeIndexes,
-  loadCommunityTypeIndexes,
   loadOrCreateIfNotExists,
+} from './logic/solidLogicSingleton'
+
+export {
+  ensureLoadedPreferences,
+  loadMe,
+  getPodRoot,
+  getMainInbox,
+  findStorage,
+   //NEW content from discovery
   loadPreferences,
   loadProfile,
-  loadTypeIndexesFor,
-  registerInstanceInTypeIndex,
-  suggestPreferencesFile,
-  suggestPrivateTypeIndex,
-  suggestPublicTypeIndex,
-  uniqueNodes
-} from './discovery/discoveryLogic'
+  //NEW function for discovery
+  silencedLoadPreferences
+} from './logic/solidLogicSingleton'
 
-export { SolidLogic } from './logic/SolidLogic'
-export { offlineTestID, appContext } from './authn/authUtil'
-export { ACL_LINK } from './util/UtilityLogic'
 export { getSuggestedIssuers } from './issuer/issuerLogic'
+
+export {
+    isContainer,
+    createContainer,
+    getContainerElements,
+    getContainerMembers
+} from './logic/solidLogicSingleton'
+
+export { authn, authSession, store } from './logic/solidLogicSingleton'
+
+//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 { solidLogicSingleton } from './logic/solidLogicSingleton'
+export { UnauthorizedError, CrossOriginForbiddenError, SameOriginForbiddenError, NotFoundError, FetchError, NotEditableError, WebOperationError } from './logic/CustomError'
+

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/solidLogicSingleton.ts

@@ -1,20 +1,173 @@
-import * as debug from "../util/debug"
+import * as rdf from "rdflib"
+import { SolidAuthnLogic } from "../authn/SolidAuthnLogic"
 import { authSession } from "../authSession/authSession"
-import { SolidLogic } from "./SolidLogic"
+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"
 
 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)
     }
 }
 
-//this const makes solidLogicSingleton global accessible in mashlib
-const solidLogicSingleton = new SolidLogic({ fetch: _fetch }, authSession)
+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
 
-debug.log('Unique quadstore initialized.')
+const utilityLogic = createUtilityLogic(store, aclLogic, containerLogic)
+const {
+    recursiveDelete,
+    setSinglePeerAccess,
+    createEmptyRdfDoc,
+    followOrCreateLink,
+    loadOrCreateIfNotExists
+} = utilityLogic
+
+const profileLogic = createProfileLogic(store, authn, utilityLogic)
+const {
+    ensureLoadedPreferences,
+    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 {
+    ensureTypeIndexes,
+    loadTypeIndexes,
+    registerInTypeIndex,
+    loadIndex,
+    ensureOneTypeIndex,
+    putIndex,
+    makeIndexIfNecessary,
+    loadIndexes,
+    getTypeIndex,
+    getRegistrations,
+    loadTypeIndexesFor,
+    loadCommunityTypeIndexes,
+    loadAllTypeIndexes,
+    getScopedAppInstances,
+    getAppInstances,
+    suggestPublicTypeIndex,
+    suggestPrivateTypeIndex,
+    registerInstanceInTypeIndex,
+    deleteTypeIndexRegistration,
+    getScopedAppsFromIndex
+} = typeIndexLogic
+
+export {
+    store,
+    authn,
+    authSession,
+    //unilityLogic
+    recursiveDelete,
+    setSinglePeerAccess,
+    createEmptyRdfDoc,
+    followOrCreateLink,
+    loadOrCreateIfNotExists,
+    //containerLogic
+    isContainer,
+    createContainer,
+    getContainerElements,
+    getContainerMembers,
+    //typeIndexLogic
+    ensureTypeIndexes,
+    loadTypeIndexes,
+    registerInTypeIndex,
+    loadIndex,
+    ensureOneTypeIndex,
+    putIndex,
+    makeIndexIfNecessary,
+    loadIndexes,
+    getTypeIndex,
+    getRegistrations,
+    loadTypeIndexesFor,
+    loadCommunityTypeIndexes,
+    loadAllTypeIndexes,
+    getScopedAppInstances,
+    getAppInstances,
+    suggestPublicTypeIndex,
+    suggestPrivateTypeIndex,
+    registerInstanceInTypeIndex,
+    deleteTypeIndexRegistration,
+    getScopedAppsFromIndex,
+    //profileLogic
+    ensureLoadedPreferences,
+    loadMe,
+    getPodRoot,
+    getMainInbox,
+    findStorage,
+    loadPreferences,
+    loadProfile,
+    silencedLoadPreferences,
+    //inboxLogic
+    createInboxFor,
+    getNewMessages,
+    markAsRead,
+    //chatLogic
+    setAcl,
+    addToPrivateTypeIndex,
+    findChat,
+    createChatThing,
+    getChat,
+    sendInvite,
+    mintNew,
+    //aclLogic
+    findAclDocUrl,
+    setACLUserPublic,
+    genACLText
+}
 
-export { solidLogicSingleton }

package/src/profile/profileLogic.ts

@@ -0,0 +1,134 @@
+import { NamedNode } from "rdflib";
+import { CrossOriginForbiddenError, FetchError, NotEditableError, SameOriginForbiddenError, UnauthorizedError, WebOperationError } from "../logic/CustomError";
+import { AuthenticationContext } from "../types";
+import * as debug from "../util/debug";
+import { differentOrigin, suggestPreferencesFile } from "../util/utils";
+import { ns as namespace } from '../util/ns'
+
+export function createProfileLogic(store, authn, utilityLogic) {
+    const ns = namespace
+
+    async function ensureLoadedPreferences (context: AuthenticationContext) {
+        if (!context.me) throw new Error('@@ ensureLoadedPreferences: no user specified')
+        context.publicProfile = await loadProfile(context.me)
+        context.preferencesFile = await silencedLoadPreferences(context.me)
+        return context
+    }
+
+    /**
+     * loads the preference without throwing errors - if it can create it it does so.
+     * remark: it still throws error if it cannot load profile.
+     * @param user 
+     * @returns undefined if preferenceFile cannot be returned or NamedNode if it can find it or create it
+     */
+    async function silencedLoadPreferences(user: NamedNode): Promise <NamedNode | undefined> {
+        try {
+            return await loadPreferences(user)
+        } catch (err) {
+            return undefined
+        }
+    }
+
+    /**
+     * loads the preference without returning different errors if it cannot create or load it.
+     * remark: it also throws error if it cannot load profile.
+     * @param user 
+     * @returns undefined if preferenceFile cannot be an Error or NamedNode if it can find it or create it
+     */
+    async function loadPreferences (user: NamedNode): Promise <NamedNode> {
+        await loadProfile(user)
+
+        const possiblePreferencesFile = suggestPreferencesFile(user)
+        let preferencesFile
+        try {
+            preferencesFile = await utilityLogic.followOrCreateLink(user, ns.space('preferencesFile') as NamedNode, possiblePreferencesFile, user.doc())
+        } catch (err) {
+            const message = `User ${user} has no pointer in profile to preferences file.`
+            debug.warn(message)
+            // we are listing the possible errors
+            if (err instanceof NotEditableError) { throw err }
+            if (err instanceof WebOperationError) { throw err }
+            if (err instanceof UnauthorizedError) { throw err }
+            if (err instanceof CrossOriginForbiddenError) { throw err }
+            if (err instanceof SameOriginForbiddenError) { throw err }
+            if (err instanceof FetchError) { throw err }
+            throw err
+        }
+
+        let response
+        try {
+            response = await store.fetcher.load(preferencesFile as NamedNode)
+        } catch (err) { // Maybe a permission problem or origin problem
+            const msg = `Unable to load preference of user ${user}: ${err}`
+            debug.warn(msg)
+            if (err.response.status === 401) {
+                throw new UnauthorizedError();
+            }
+            if (err.response.status === 403) {
+                if (differentOrigin(preferencesFile)) {
+                throw new CrossOriginForbiddenError();
+                }
+                throw new SameOriginForbiddenError();
+            }
+            /*if (err.response.status === 404) {
+                throw new NotFoundError();
+            }*/
+            throw new Error(msg)
+        }
+        return preferencesFile as NamedNode
+    }
+
+    async function loadProfile (user: NamedNode):Promise <NamedNode> {
+        if (!user) {
+            throw new Error(`loadProfile: no user given.`)
+        }
+        try {
+            await store.fetcher.load(user.doc())
+        } catch (err) {
+            throw new Error(`Unable to load profile of user ${user}: ${err}`)
+        }
+        return user.doc()
+    }
+
+    async function loadMe(): Promise<NamedNode> {
+        const me = authn.currentUser();
+        if (me === null) {
+            throw new Error("Current user not found! Not logged in?");
+        }
+        await store.fetcher.load(me.doc());
+        return me;
+    }
+
+    function getPodRoot(user: NamedNode): NamedNode {
+        const podRoot = findStorage(user);
+        if (!podRoot) {
+            throw new Error("User pod root not found!");
+        }
+        return podRoot as NamedNode;
+    }
+
+    async function getMainInbox(user: NamedNode): Promise<NamedNode> {
+        await store.fetcher.load(user);
+        const mainInbox = store.any(user, ns.ldp("inbox"), undefined, user.doc());
+        if (!mainInbox) {
+            throw new Error("User main inbox not found!");
+        }
+        return mainInbox as NamedNode;
+    }
+
+    function findStorage(me: NamedNode) {
+        return store.any(me, ns.space("storage"), undefined, me.doc());
+    }
+
+    return {
+        ensureLoadedPreferences,
+        loadMe,
+        getPodRoot,
+        getMainInbox,
+        findStorage,
+        loadPreferences,
+        loadProfile,
+        silencedLoadPreferences
+    }
+}
+