solid-logic 1.3.17-8a332867 → 1.3.17-a27c1702

package/lib/util/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../src/util/utils.ts"],"names":[],"mappings":";;;AAAA,iCAAwC;AAExC,SAAgB,QAAQ,CAAC,GAAc;IACnC,OAAO,IAAA,YAAG,EAAC,GAAG,CAAC,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,CAAC,EAAE,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;AACzD,CAAC;AAFD,4BAEC;AAED,SAAgB,WAAW,CAAE,GAAgB;IACzC,IAAM,IAAI,GAAG,GAAG,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,CAAC,CAAC,GAAG,EAAL,CAAK,CAAC,CAAA;IAChC,IAAM,GAAG,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,CAAA;IACzB,IAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;IAC7B,IAAM,IAAI,GAAG,KAAK,CAAC,GAAG,CAAC,UAAA,CAAC,IAAI,OAAA,IAAI,kBAAS,CAAC,CAAC,CAAC,EAAhB,CAAgB,CAAC,CAAA;IAC7C,OAAO,IAAI,CAAA,CAAC,4DAA4D;AAC5E,CAAC;AAND,kCAMC;AAED,SAAgB,aAAa,CAAC,OAAe,EAAE,IAAU;IACrD,IAAM,IAAI,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;IACnC,IAAM,KAAK,GAAG,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,GAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IACvD,IAAM,GAAG,GAAG,CAAC,GAAG,GAAG,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAClD,IAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACjC,IAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,GAAE,CAAC,CAAE,CAAC;IACzC,OAAO,IAAI,GAAG,CAAC,oBAAa,IAAI,cAAI,KAAK,cAAI,GAAG,cAAI,QAAQ,CAAE,EAAE,OAAO,CAAC,CAAC,QAAQ,EAAE,CAAC;AACxF,CAAC;AAPD,sCAOC;AAED,SAAgB,eAAe,CAAC,GAAG;IAC/B,IAAI,CAAC,GAAG,EAAE;QACN,OAAO,IAAI,CAAC;KACf;IACD,OAAO,CACH,UAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,MAAG,KAAK,IAAI,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,MAAM,CAC7D,CAAC;AACN,CAAC;AAPD,0CAOC;AAED,SAAgB,sBAAsB,CAAE,EAAY;IAChD,IAAM,QAAQ,GAAG,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,CAAA;IAC1E,uFAAuF;IACvF,IAAM,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,EAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,YAAY,CAAA;IAC1E,IAAM,OAAO,GAAG,SAAS,GAAG,iBAAiB,CAAA;IAC7C,OAAO,IAAA,YAAG,EAAC,OAAO,CAAC,CAAA;AACvB,CAAC;AAND,wDAMC;AAED,SAAgB,sBAAsB,CAClC,OAAkB,EAClB,OAAkB;IAElB,cAAc;IACd,mEAAmE;IACnE,IAAM,gBAAgB,GAAG,IAAI,GAAG,CAC5B,0BAAmB,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,IAAI,MAAG,EACjD,OAAO,CAAC,KAAK,CAChB,CAAC,QAAQ,EAAE,CAAC;IACb,OAAO,IAAI,kBAAS,CAAC,gBAAgB,CAAC,CAAC;AAC3C,CAAC;AAXD,wDAWC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "solid-logic",
-  "version": "1.3.17-8a332867",
+  "version": "1.3.17-a27c1702",
   "description": "Core business logic of Solid OS",
   "main": "lib/index.js",
   "scripts": {
@@ -8,6 +8,7 @@
     "clean": "rm -rf lib",
     "lint": "eslint ./src",
     "test": "jest",
+    "test-debug": "node --inspect-brk ./node_modules/.bin/jest -i --env jest-environment-node-debug",
     "preversion": "npm test",
     "postversion": "git push --follow-tags",
     "ignore:prepublishOnly": "npm run build",
@@ -35,6 +36,7 @@
     "@typescript-eslint/parser": "^5.19.0",
     "eslint": "^8.13.0",
     "jest": "^27.5.1",
+    "jest-environment-node-debug": "^2.0.0",
     "jest-fetch-mock": "^3.0.3",
     "typescript": "^4.6.3"
   },

package/src/acl/aclLogic.ts

@@ -1,137 +1,155 @@
-/**
- * Simple Access Control
- *
- * This function sets up a simple default ACL for a resource, with
- * RWC for the owner, and a specified access (default none) for the public.
- * In all cases owner has read write control.
- * Parameter lists modes allowed to public
- *
- * @param options
- * @param options.public eg ['Read', 'Write']
- *
- * @returns Resolves with aclDoc uri on successful write
- */
+import { graph, NamedNode, Namespace, serialize, sym } from "rdflib"
+import { ns as namespace } from '../util/ns'
 
-import { graph, NamedNode, Namespace, serialize } from "rdflib"
-import solidNamespace from 'solid-namespace'
-import * as $rdf from 'rdflib'
-import { solidLogicSingleton } from "../logic/solidLogicSingleton"
-import { ACL_LINK } from "../util/UtilityLogic"
 
-export const ns = solidNamespace($rdf)
+export const ACL_LINK = sym(
+    "http://www.iana.org/assignments/link-relations/acl"
+);
 
-export function setACLUserPublic ( 
-docURI: string,
-me: NamedNode,
-options: {
-    defaultForNew?: boolean,
-    public?: []
-}
-): Promise<NamedNode> {
-const aclDoc = solidLogicSingleton.store.any(
-    solidLogicSingleton.store.sym(docURI),
-    ACL_LINK
-)
+export function createAclLogic(store) {
 
-return Promise.resolve()
-    .then(() => {
-    if (aclDoc) {
-        return aclDoc as NamedNode
+    const ns = namespace
+    
+    async function findAclDocUrl(url: string) {
+        const doc = store.sym(url);
+        await store.fetcher.load(doc);
+        const docNode = store.any(doc, ACL_LINK);
+        if (!docNode) {
+            throw new Error(`No ACL link discovered for ${url}`);
+        }
+        return docNode.value;
     }
-
-    return fetchACLRel(docURI).catch(err => {
-        throw new Error(`Error fetching rel=ACL header for ${docURI}: ${err}`)
-    })
-    })
-    .then(aclDoc => {
-    const aclText = genACLText(docURI, me, aclDoc.uri, options)
-    if (!solidLogicSingleton.store.fetcher) {
-        throw new Error('Cannot PUT this, store has no fetcher')
+    /**
+     * Simple Access Control
+     *
+     * This function sets up a simple default ACL for a resource, with
+     * RWC for the owner, and a specified access (default none) for the public.
+     * In all cases owner has read write control.
+     * Parameter lists modes allowed to public
+     *
+     * @param options
+     * @param options.public eg ['Read', 'Write']
+     *
+     * @returns Resolves with aclDoc uri on successful write
+     */
+    function setACLUserPublic ( 
+    docURI: string,
+    me: NamedNode,
+    options: {
+        defaultForNew?: boolean,
+        public?: []
     }
-    return solidLogicSingleton.store.fetcher
-        .webOperation('PUT', aclDoc.uri, {
-        data: aclText,
-        contentType: 'text/turtle'
-        })
-        .then(result => {
-        if (!result.ok) {
-            throw new Error('Error writing ACL text: ' + result.error)
+    ): Promise<NamedNode> {
+    const aclDoc = store.any(
+        store.sym(docURI),
+        ACL_LINK
+    )
+
+    return Promise.resolve()
+        .then(() => {
+        if (aclDoc) {
+            return aclDoc as NamedNode
         }
 
-        return aclDoc
+        return fetchACLRel(docURI).catch(err => {
+            throw new Error(`Error fetching rel=ACL header for ${docURI}: ${err}`)
+        })
         })
-    })
-}
+        .then(aclDoc => {
+        const aclText = genACLText(docURI, me, aclDoc.uri, options)
+        if (!store.fetcher) {
+            throw new Error('Cannot PUT this, store has no fetcher')
+        }
+        return store.fetcher
+            .webOperation('PUT', aclDoc.uri, {
+            data: aclText,
+            contentType: 'text/turtle'
+            })
+            .then(result => {
+            if (!result.ok) {
+                throw new Error('Error writing ACL text: ' + result.error)
+            }
 
-/**
- * @param docURI
- * @returns
- */
-function fetchACLRel (docURI: string): Promise<NamedNode> {
-    const fetcher = solidLogicSingleton.store.fetcher
-    if (!fetcher) {
-        throw new Error('Cannot fetch ACL rel, store has no fetcher')
+            return aclDoc
+            })
+        })
     }
 
-    return fetcher.load(docURI).then(result => {
-        if (!result.ok) {
-        throw new Error('fetchACLRel: While loading:' + (result as any).error)
+    /**
+     * @param docURI
+     * @returns
+     */
+    function fetchACLRel (docURI: string): Promise<NamedNode> {
+        const fetcher = store.fetcher
+        if (!fetcher) {
+            throw new Error('Cannot fetch ACL rel, store has no fetcher')
         }
 
-        const aclDoc = solidLogicSingleton.store.any(
-        solidLogicSingleton.store.sym(docURI),
-        ACL_LINK
-        )
+        return fetcher.load(docURI).then(result => {
+            if (!result.ok) {
+            throw new Error('fetchACLRel: While loading:' + (result as any).error)
+            }
 
-        if (!aclDoc) {
-        throw new Error('fetchACLRel: No Link rel=ACL header for ' + docURI)
-        }
+            const aclDoc = store.any(
+            store.sym(docURI),
+            ACL_LINK
+            )
 
-        return aclDoc as NamedNode
-    })
-}
+            if (!aclDoc) {
+            throw new Error('fetchACLRel: No Link rel=ACL header for ' + docURI)
+            }
+
+            return aclDoc as NamedNode
+        })
+    }
 
-/**
- * @param docURI
- * @param me
- * @param aclURI
- * @param options
- *
- * @returns Serialized ACL
- */
-export function genACLText (
-docURI: string,
-me: NamedNode,
-aclURI: string,
-options: {
-    defaultForNew?: boolean,
-    public?: []
-} = {}
-): string | undefined {
-const optPublic = options.public || []
-const g = graph()
-const auth = Namespace('http://www.w3.org/ns/auth/acl#')
-let a = g.sym(`${aclURI}#a1`)
-const acl = g.sym(aclURI)
-const doc = g.sym(docURI)
-g.add(a, ns.rdf('type'), auth('Authorization'), acl)
-g.add(a, auth('accessTo'), doc, acl)
-if (options.defaultForNew) {
-    g.add(a, auth('default'), doc, acl)
-}
-g.add(a, auth('agent'), me, acl)
-g.add(a, auth('mode'), auth('Read'), acl)
-g.add(a, auth('mode'), auth('Write'), acl)
-g.add(a, auth('mode'), auth('Control'), acl)
+    /**
+     * @param docURI
+     * @param me
+     * @param aclURI
+     * @param options
+     *
+     * @returns Serialized ACL
+     */
+    function genACLText (
+    docURI: string,
+    me: NamedNode,
+    aclURI: string,
+    options: {
+        defaultForNew?: boolean,
+        public?: []
+    } = {}
+    ): string | undefined {
+        const optPublic = options.public || []
+        const g = graph()
+        const auth = Namespace('http://www.w3.org/ns/auth/acl#')
+        let a = g.sym(`${aclURI}#a1`)
+        const acl = g.sym(aclURI)
+        const doc = g.sym(docURI)
+        g.add(a, ns.rdf('type'), auth('Authorization'), acl)
+        g.add(a, auth('accessTo'), doc, acl)
+        if (options.defaultForNew) {
+            g.add(a, auth('default'), doc, acl)
+        }
+        g.add(a, auth('agent'), me, acl)
+        g.add(a, auth('mode'), auth('Read'), acl)
+        g.add(a, auth('mode'), auth('Write'), acl)
+        g.add(a, auth('mode'), auth('Control'), acl)
 
-if (optPublic.length) {
-    a = g.sym(`${aclURI}#a2`)
-    g.add(a, ns.rdf('type'), auth('Authorization'), acl)
-    g.add(a, auth('accessTo'), doc, acl)
-    g.add(a, auth('agentClass'), ns.foaf('Agent'), acl)
-    for (let p = 0; p < optPublic.length; p++) {
-    g.add(a, auth('mode'), auth(optPublic[p]), acl) // Like 'Read' etc
+        if (optPublic.length) {
+            a = g.sym(`${aclURI}#a2`)
+            g.add(a, ns.rdf('type'), auth('Authorization'), acl)
+            g.add(a, auth('accessTo'), doc, acl)
+            g.add(a, auth('agentClass'), ns.foaf('Agent'), acl)
+            for (let p = 0; p < optPublic.length; p++) {
+            g.add(a, auth('mode'), auth(optPublic[p]), acl) // Like 'Read' etc
+            }
+        }
+        return serialize(acl, g, aclURI)
+    }
+    return {
+        findAclDocUrl,
+        setACLUserPublic,
+        genACLText
     }
-}
-return serialize(acl, g, aclURI)
-}
+}

package/src/authn/SolidAuthnLogic.ts

@@ -3,6 +3,7 @@ import { appContext, offlineTestID } from "./authUtil";
 import * as debug from '../util/debug'
 import { Session } from "@inrupt/solid-client-authn-browser";
 import { AuthenticationContext, AuthnLogic } from "../types";
+
 export class SolidAuthnLogic implements AuthnLogic {
   private session: Session;
 
@@ -58,10 +59,10 @@ export class SolidAuthnLogic implements AuthnLogic {
       const curUrl = new URL(window.location.href)
       if (curUrl.hash !== postLoginRedirectHash) {
         if (history.pushState) {
-          // console.log('Setting window.location.has using pushState')
+          // debug.log('Setting window.location.has using pushState')
           history.pushState(null, document.title, postLoginRedirectHash)
         } else {
-          // console.warn('Setting window.location.has using location.hash')
+          // debug.warn('Setting window.location.has using location.hash')
           location.hash = postLoginRedirectHash
         }
         curUrl.hash = postLoginRedirectHash

package/src/chat/chatLogic.ts

@@ -0,0 +1,225 @@
+import { NamedNode, Node, st, term } from "rdflib"
+import { CreatedPaneOptions, NewPaneOptions } from "../types"
+import { determineChatContainer, newThing } from "../util/utils"
+import { ns as namespace } from '../util/ns'
+
+const CHAT_LOCATION_IN_CONTAINER = "index.ttl#this";
+
+export function createChatLogic(store, profileLogic) {
+    const ns = namespace
+    
+    async function setAcl(
+        chatContainer: NamedNode,
+        me: NamedNode,
+        invitee: NamedNode
+    ): Promise<void> {
+        // 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 store.fetcher.load(chatContainer);
+
+        // FIXME: check the Why value on this quad:
+        const chatAclDoc = store.any(
+            chatContainer,
+            new NamedNode("http://www.iana.org/assignments/link-relations/acl")
+        );
+        if (!chatAclDoc) {
+            throw new Error("Chat ACL doc not found!");
+        }
+
+        const aclBody = `
+            @prefix acl: <http://www.w3.org/ns/auth/acl#>.
+            <#owner>
+            a acl:Authorization;
+            acl:agent <${me.value}>;
+            acl:accessTo <.>;
+            acl:default <.>;
+            acl:mode
+                acl:Read, acl:Write, acl:Control.
+            <#invitee>
+            a acl:Authorization;
+            acl:agent <${invitee.value}>;
+            acl:accessTo <.>;
+            acl:default <.>;
+            acl:mode
+                acl:Read, acl:Append.
+            `;
+        await store.fetcher.webOperation("PUT", chatAclDoc.value, {
+            data: aclBody,
+            contentType: "text/turtle",
+        });
+    }
+
+    async function addToPrivateTypeIndex(chatThing, me) {
+        // Add to private type index
+        const privateTypeIndex = store.any(
+            me,
+            ns.solid("privateTypeIndex")
+        ) as NamedNode | null;
+        if (!privateTypeIndex) {
+            throw new Error("Private type index not found!");
+        }
+        await store.fetcher.load(privateTypeIndex);
+        const reg = newThing(privateTypeIndex);
+        const ins = [
+            st(
+                reg,
+                ns.rdf("type"),
+                ns.solid("TypeRegistration"),
+                privateTypeIndex.doc()
+            ),
+            st(
+                reg,
+                ns.solid("forClass"),
+                ns.meeting("LongChat"),
+                privateTypeIndex.doc()
+            ),
+            st(reg, ns.solid("instance"), chatThing, privateTypeIndex.doc()),
+        ];
+        await new Promise((resolve, reject) => {
+            store.updater.update([], ins, function (_uri, ok, errm) {
+                if (!ok) {
+                    reject(new Error(errm));
+                } else {
+                    resolve(null);
+                }
+            });
+        });
+    }
+
+    async function findChat(invitee: NamedNode) {
+        const me = await profileLogic.loadMe();
+        const podRoot = await profileLogic.getPodRoot(me);
+        const chatContainer = determineChatContainer(invitee, podRoot);
+        let exists = true;
+        try {
+            await store.fetcher.load(
+                new NamedNode(chatContainer.value + "index.ttl#this")
+            );
+        } catch (e) {
+            exists = false;
+        }
+        return { me, chatContainer, exists };
+    }
+
+    async function createChatThing(
+        chatContainer: NamedNode,
+        me: NamedNode
+    ): Promise<NamedNode> {
+        const created = await mintNew({
+            me,
+            newBase: chatContainer.value,
+        });
+        return created.newInstance;
+    }
+
+    function mintNew(newPaneOptions: NewPaneOptions): Promise<CreatedPaneOptions> {
+        const kb = store;
+        const updater = kb.updater;
+        if (newPaneOptions.me && !newPaneOptions.me.uri) {
+            throw new Error("chat mintNew:  Invalid userid " + newPaneOptions.me);
+        }
+
+        const newInstance = (newPaneOptions.newInstance =
+            newPaneOptions.newInstance ||
+            kb.sym(newPaneOptions.newBase + CHAT_LOCATION_IN_CONTAINER));
+        const newChatDoc = newInstance.doc();
+
+        kb.add(
+            newInstance,
+            ns.rdf("type"),
+            ns.meeting("LongChat"),
+            newChatDoc
+        );
+        kb.add(newInstance, ns.dc("title"), "Chat channel", newChatDoc);
+        kb.add(
+            newInstance,
+            ns.dc("created"),
+            term<Node>(new Date(Date.now())),
+            newChatDoc
+        );
+        if (newPaneOptions.me) {
+            kb.add(newInstance, ns.dc("author"), newPaneOptions.me, newChatDoc);
+        }
+
+        return new Promise(function (resolve, reject) {
+            updater?.put(
+                newChatDoc,
+                kb.statementsMatching(undefined, undefined, undefined, newChatDoc),
+                "text/turtle",
+                function (uri2, ok, message) {
+                    if (ok) {
+                        resolve({
+                            ...newPaneOptions,
+                            newInstance,
+                        });
+                    } else {
+                        reject(
+                            new Error(
+                                "FAILED to save new chat channel at: " + uri2 + " : " + message
+                            )
+                        );
+                    }
+                }
+            );
+        });
+    }
+
+    /**
+     * Find (and optionally create) an individual chat between the current user and the given invitee
+     * @param invitee - The person to chat with
+     * @param createIfMissing - Whether the chat should be created, if missing
+     * @returns null if missing, or a node referring to an already existing chat, or the newly created chat
+     */
+    async function getChat(
+        invitee: NamedNode,
+        createIfMissing = true
+    ): Promise<NamedNode | null> {
+        const { me, chatContainer, exists } = await findChat(invitee);
+        if (exists) {
+            return new NamedNode(chatContainer.value + CHAT_LOCATION_IN_CONTAINER);
+        }
+
+        if (createIfMissing) {
+            const chatThing = await createChatThing(chatContainer, me);
+            await sendInvite(invitee, chatThing);
+            await setAcl(chatContainer, me, invitee);
+            await addToPrivateTypeIndex(chatThing, me);
+            return chatThing;
+        }
+        return null;
+    }
+
+    async function sendInvite(invitee: NamedNode, chatThing: NamedNode) {
+        await store.fetcher.load(invitee.doc());
+        const inviteeInbox = store.any(
+            invitee,
+            ns.ldp("inbox"),
+            undefined,
+            invitee.doc()
+        );
+        if (!inviteeInbox) {
+            throw new Error(`Invitee inbox not found! ${invitee.value}`);
+        }
+        const inviteBody = `
+        <> a <http://www.w3.org/ns/pim/meeting#LongChatInvite> ;
+        ${ns.rdf("seeAlso")} <${chatThing.value}> .
+        `;
+
+        const inviteResponse = await store.fetcher.webOperation(
+            "POST",
+            inviteeInbox.value,
+            {
+                data: inviteBody,
+                contentType: "text/turtle",
+            }
+        );
+        const locationStr = inviteResponse?.headers.get("location");
+        if (!locationStr) {
+            throw new Error(`Invite sending returned a ${inviteResponse?.status}`);
+        }
+    }
+    return {
+        setAcl, addToPrivateTypeIndex, findChat, createChatThing, getChat, sendInvite, mintNew
+    }
+}

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