solid-logic 3.0.9-f51524a8 → 3.0.9-fa4d7e8

package/src/chat/chatLogic.ts

@@ -1,9 +1,9 @@
-import { NamedNode, Node, st, term } from 'rdflib'
-import { ChatLogic, CreatedPaneOptions, NewPaneOptions, Chat } from '../types'
-import { ns as namespace } from '../util/ns'
-import { determineChatContainer, newThing } from '../util/utils'
+import { NamedNode, Node, st, term } from "rdflib"
+import { ChatLogic, CreatedPaneOptions, NewPaneOptions, Chat } from "../types"
+import { ns as namespace } from "../util/ns";
+import { determineChatContainer, newThing } from "../util/utils"
 
-const CHAT_LOCATION_IN_CONTAINER = 'index.ttl#this'
+const CHAT_LOCATION_IN_CONTAINER = "index.ttl#this"
 
 export function createChatLogic(store, profileLogic): ChatLogic {
     const ns = namespace
@@ -16,15 +16,15 @@ export function createChatLogic(store, profileLogic): ChatLogic {
         // 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)
+        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')
-        )
+            new NamedNode("http://www.iana.org/assignments/link-relations/acl")
+        );
         if (!chatAclDoc) {
-            throw new Error('Chat ACL doc not found!')
+            throw new Error("Chat ACL doc not found!");
         }
 
         const aclBody = `
@@ -43,64 +43,64 @@ export function createChatLogic(store, profileLogic): ChatLogic {
             acl:default <.>;
             acl:mode
                 acl:Read, acl:Append.
-            `
-        await store.fetcher.webOperation('PUT', chatAclDoc.value, {
+            `;
+        await store.fetcher.webOperation("PUT", chatAclDoc.value, {
             data: aclBody,
-            contentType: 'text/turtle',
-        })
+            contentType: "text/turtle",
+        });
     }
 
     async function addToPrivateTypeIndex(chatThing, me) {
         // Add to private type index
         const privateTypeIndex = store.any(
             me,
-            ns.solid('privateTypeIndex')
-        ) as NamedNode | null
+            ns.solid("privateTypeIndex")
+        ) as NamedNode | null;
         if (!privateTypeIndex) {
-            throw new Error('Private type index not found!')
+            throw new Error("Private type index not found!");
         }
-        await store.fetcher.load(privateTypeIndex)
-        const reg = newThing(privateTypeIndex)
+        await store.fetcher.load(privateTypeIndex);
+        const reg = newThing(privateTypeIndex);
         const ins = [
             st(
                 reg,
-                ns.rdf('type'),
-                ns.solid('TypeRegistration'),
+                ns.rdf("type"),
+                ns.solid("TypeRegistration"),
                 privateTypeIndex.doc()
             ),
             st(
                 reg,
-                ns.solid('forClass'),
-                ns.meeting('LongChat'),
+                ns.solid("forClass"),
+                ns.meeting("LongChat"),
                 privateTypeIndex.doc()
             ),
-            st(reg, ns.solid('instance'), chatThing, 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))
+                    reject(new Error(errm));
                 } else {
-                    resolve(null)
+                    resolve(null);
                 }
-            })
-        })
+            });
+        });
     }
 
     async function findChat(invitee: NamedNode): Promise<Chat> {
-        const me = await profileLogic.loadMe()
-        const podRoot = await profileLogic.getPodRoot(me)
-        const chatContainer = determineChatContainer(invitee, podRoot)
-        let exists = true
+        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')
-            )
+                new NamedNode(chatContainer.value + "index.ttl#this")
+            );
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
         } catch (e) {
-            exists = false
+            exists = false;
         }
-        return { me, chatContainer, exists }
+        return { me, chatContainer, exists };
     }
 
     async function createChatThing(
@@ -110,60 +110,60 @@ export function createChatLogic(store, profileLogic): ChatLogic {
         const created = await mintNew({
             me,
             newBase: chatContainer.value,
-        })
-        return created.newInstance
+        });
+        return created.newInstance;
     }
 
     function mintNew(newPaneOptions: NewPaneOptions): Promise<CreatedPaneOptions> {
-        const kb = store
-        const updater = kb.updater
+        const kb = store;
+        const updater = kb.updater;
         if (newPaneOptions.me && !newPaneOptions.me.uri) {
-            throw new Error('chat mintNew:  Invalid userid ' + newPaneOptions.me)
+            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.sym(newPaneOptions.newBase + CHAT_LOCATION_IN_CONTAINER));
+        const newChatDoc = newInstance.doc();
 
         kb.add(
             newInstance,
-            ns.rdf('type'),
-            ns.meeting('LongChat'),
+            ns.rdf("type"),
+            ns.meeting("LongChat"),
             newChatDoc
-        )
-        kb.add(newInstance, ns.dc('title'), 'Chat channel', newChatDoc)
+        );
+        kb.add(newInstance, ns.dc("title"), "Chat channel", newChatDoc);
         kb.add(
             newInstance,
-            ns.dc('created'),
+            ns.dc("created"),
             term<Node>(new Date(Date.now())),
             newChatDoc
-        )
+        );
         if (newPaneOptions.me) {
-            kb.add(newInstance, ns.dc('author'), newPaneOptions.me, newChatDoc)
+            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',
+                "text/turtle",
                 function (uri2, ok, message) {
                     if (ok) {
                         resolve({
                             ...newPaneOptions,
                             newInstance,
-                        })
+                        });
                     } else {
                         reject(
                             new Error(
-                                'FAILED to save new chat channel at: ' + uri2 + ' : ' + message
+                                "FAILED to save new chat channel at: " + uri2 + " : " + message
                             )
-                        )
+                        );
                     }
                 }
-            )
-        })
+            );
+        });
     }
 
     /**
@@ -176,48 +176,48 @@ export function createChatLogic(store, profileLogic): ChatLogic {
         invitee: NamedNode,
         createIfMissing = true
     ): Promise<NamedNode | null> {
-        const { me, chatContainer, exists } = await findChat(invitee)
+        const { me, chatContainer, exists } = await findChat(invitee);
         if (exists) {
-            return new NamedNode(chatContainer.value + CHAT_LOCATION_IN_CONTAINER)
+            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
+            const chatThing = await createChatThing(chatContainer, me);
+            await sendInvite(invitee, chatThing);
+            await setAcl(chatContainer, me, invitee);
+            await addToPrivateTypeIndex(chatThing, me);
+            return chatThing;
         }
-        return null
+        return null;
     }
 
     async function sendInvite(invitee: NamedNode, chatThing: NamedNode) {
-        await store.fetcher.load(invitee.doc())
+        await store.fetcher.load(invitee.doc());
         const inviteeInbox = store.any(
             invitee,
-            ns.ldp('inbox'),
+            ns.ldp("inbox"),
             undefined,
             invitee.doc()
-        )
+        );
         if (!inviteeInbox) {
-            throw new Error(`Invitee inbox not found! ${invitee.value}`)
+            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}> .
-        `
+        ${ns.rdf("seeAlso")} <${chatThing.value}> .
+        `;
 
         const inviteResponse = await store.fetcher?.webOperation(
-            'POST',
+            "POST",
             inviteeInbox.value,
             {
                 data: inviteBody,
-                contentType: 'text/turtle',
+                contentType: "text/turtle",
             }
-        )
-        const locationStr = inviteResponse?.headers.get('location')
+        );
+        const locationStr = inviteResponse?.headers.get("location");
         if (!locationStr) {
-            throw new Error(`Invite sending returned a ${inviteResponse?.status}`)
+            throw new Error(`Invite sending returned a ${inviteResponse?.status}`);
         }
     }
     return {

package/src/inbox/inboxLogic.ts

@@ -1,54 +1,54 @@
-import { NamedNode } from 'rdflib'
-import { InboxLogic } from '../types'
-import { getArchiveUrl } from '../util/utils'
+import { NamedNode } from "rdflib";
+import { InboxLogic } from "../types";
+import { getArchiveUrl } from "../util/utils";
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export function createInboxLogic(store, profileLogic, utilityLogic, containerLogic, aclLogic): InboxLogic {
 
     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 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
+      });
+      return ourInbox;
   }
 
   async function getNewMessages(
       user?: NamedNode
     ): Promise<NamedNode[]> {
       if (!user) {
-        user = await profileLogic.loadMe()
+        user = await profileLogic.loadMe();
       }
-      const inbox = await profileLogic.getMainInbox(user)
-      const urls = await containerLogic.getContainerMembers(inbox)
-      return urls.filter(url => !containerLogic.isContainer(url))
+      const inbox = await profileLogic.getMainInbox(user);
+      const urls = await containerLogic.getContainerMembers(inbox);
+      return urls.filter(url => !containerLogic.isContainer(url));
   }
 
   async function markAsRead(url: string, date: Date) {
-    const downloaded = await store.fetcher._fetch(url)
+    const downloaded = await store.fetcher._fetch(url);
     if (downloaded.status !== 200) {
-      throw new Error(`Not OK! ${url}`)
+      throw new Error(`Not OK! ${url}`);
     }
-    const archiveUrl = getArchiveUrl(url, date)
+    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)
+    };
+    const uploaded = await store.fetcher._fetch(archiveUrl, options);
     if (uploaded.status.toString()[0] === '2') {
       await store.fetcher._fetch(url, {
         method: 'DELETE'
-      })
+      });
     }
   }
   return {

package/src/index.ts

@@ -9,7 +9,8 @@ const store = solidLogicSingleton.store
 export { ACL_LINK } from './acl/aclLogic'
 export { offlineTestID, appContext } from './authn/authUtil'
 export { getSuggestedIssuers } from './issuer/issuerLogic'
-export type { AppDetails, SolidNamespace, AuthenticationContext, SolidLogic } from './types'
+export { createTypeIndexLogic } from './typeIndex/typeIndexLogic'
+export { AppDetails, SolidNamespace, AuthenticationContext, SolidLogic } from './types'
 export { UnauthorizedError, CrossOriginForbiddenError, SameOriginForbiddenError, NotFoundError, FetchError, NotEditableError, WebOperationError } from './logic/CustomError'
 
 export {

package/src/logic/CustomError.ts

@@ -1,9 +1,9 @@
 class CustomError extends Error {
     constructor(message?: string) {
-        super(message)
+        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
+        Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
+        this.name = new.target.name; // stack traces display correctly now
     }
 }
 
@@ -20,10 +20,10 @@ export class NotEditableError extends CustomError { }
 export class WebOperationError extends CustomError {}
 
 export class FetchError extends CustomError {
-    status: number
+    status: number;
 
     constructor(status: number, message?: string) {
-        super(message)
-        this.status = status
+        super(message);
+        this.status = status;
     }
 }

package/src/logic/solidLogic.ts

@@ -1,16 +1,16 @@
-import { Session } from '@inrupt/solid-client-authn-browser'
-import * as rdf from 'rdflib'
-import { LiveStore, NamedNode, Statement } from 'rdflib'
-import { createAclLogic } from '../acl/aclLogic'
-import { SolidAuthnLogic } from '../authn/SolidAuthnLogic'
-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, SolidLogic } from '../types'
-import * as debug from '../util/debug'
+import { Session } from "@inrupt/solid-client-authn-browser";
+import * as rdf from "rdflib";
+import { LiveStore, NamedNode, Statement } from "rdflib";
+import { createAclLogic } from "../acl/aclLogic";
+import { SolidAuthnLogic } from "../authn/SolidAuthnLogic";
+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, SolidLogic } from "../types";
+import * as debug from "../util/debug";
 /*
 ** It is important to distinquish `fetch`, a function provided by the browser
 ** and `Fetcher`, a helper object for the rdflib Store which turns it
@@ -20,10 +20,10 @@ import * as debug from '../util/debug'
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function createSolidLogic(specialFetch: { fetch: (url: any, requestInit: any) => any }, session: Session): SolidLogic {
 
-    debug.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.")
     const store: LiveStore = rdf.graph() as LiveStore
-    rdf.fetcher(store, {fetch: specialFetch.fetch}) // Attach a web I/O module, store.fetcher
-    store.updater = new rdf.UpdateManager(store) // Add real-time live updates store.updater
+    rdf.fetcher(store, {fetch: specialFetch.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
 
     const authn: AuthnLogic = new SolidAuthnLogic(session)
@@ -38,7 +38,7 @@ export function createSolidLogic(specialFetch: { fetch: (url: any, requestInit:
     debug.log('SolidAuthnLogic initialized')
 
     function load(doc: NamedNode | NamedNode[] | string) {
-        return store.fetcher.load(doc)
+        return store.fetcher.load(doc);
     }
 
     // @@@@ use the one in rdflib.js when it is available and delete this
@@ -49,16 +49,16 @@ export function createSolidLogic(specialFetch: { fetch: (url: any, requestInit:
         return new Promise((resolve, reject) => {
         store.updater.update(del, ins, function (_uri, ok, errorBody) {
             if (!ok) {
-            reject(new Error(errorBody))
+            reject(new Error(errorBody));
             } else {
-            resolve()
+            resolve();
             }
-        }) // callback
-        }) // promise
+        }); // callback
+        }); // promise
     }
 
     function clearStore() {
-        store.statements.slice().forEach(store.remove.bind(store))
+        store.statements.slice().forEach(store.remove.bind(store));
     }
 
     return {

package/src/logic/solidLogicSingleton.ts

@@ -1,6 +1,6 @@
-import * as debug from '../util/debug'
-import { authSession } from '../authSession/authSession'
-import { createSolidLogic } from './solidLogic'
+import * as debug from "../util/debug"
+import { authSession } from "../authSession/authSession"
+import { createSolidLogic } from "./solidLogic"
 
 const _fetch = async (url, requestInit) => {
     const omitCreds = requestInit && requestInit.credentials && requestInit.credentials == 'omit'

package/src/profile/profileLogic.ts

@@ -1,9 +1,9 @@
-import { NamedNode } from 'rdflib'
-import { CrossOriginForbiddenError, FetchError, NotEditableError, SameOriginForbiddenError, UnauthorizedError, WebOperationError } from '../logic/CustomError'
-import * as debug from '../util/debug'
-import { ns as namespace } from '../util/ns'
-import { differentOrigin, suggestPreferencesFile } from '../util/utils'
-import { ProfileLogic } from '../types'
+import { NamedNode } from "rdflib";
+import { CrossOriginForbiddenError, FetchError, NotEditableError, SameOriginForbiddenError, UnauthorizedError, WebOperationError } from "../logic/CustomError";
+import * as debug from "../util/debug";
+import { ns as namespace } from '../util/ns';
+import { differentOrigin, suggestPreferencesFile } from "../util/utils"
+import { ProfileLogic } from "../types"
 
 export function createProfileLogic(store, authn, utilityLogic): ProfileLogic {
     const ns = namespace
@@ -55,13 +55,13 @@ export function createProfileLogic(store, authn, utilityLogic): ProfileLogic {
             const msg = `Unable to load preference of user ${user}: ${err}`
             debug.warn(msg)
             if (err.response.status === 401) {
-                throw new UnauthorizedError()
+                throw new UnauthorizedError();
             }
             if (err.response.status === 403) {
                 if (differentOrigin(preferencesFile)) {
-                throw new CrossOriginForbiddenError()
+                throw new CrossOriginForbiddenError();
                 }
-                throw new SameOriginForbiddenError()
+                throw new SameOriginForbiddenError();
             }
             /*if (err.response.status === 404) {
                 throw new NotFoundError();
@@ -73,7 +73,7 @@ export function createProfileLogic(store, authn, utilityLogic): ProfileLogic {
 
     async function loadProfile (user: NamedNode):Promise <NamedNode> {
         if (!user) {
-            throw new Error('loadProfile: no user given.')
+            throw new Error(`loadProfile: no user given.`)
         }
         try {
             await store.fetcher.load(user.doc())
@@ -84,33 +84,33 @@ export function createProfileLogic(store, authn, utilityLogic): ProfileLogic {
     }
 
     async function loadMe(): Promise<NamedNode> {
-        const me = authn.currentUser()
+        const me = authn.currentUser();
         if (me === null) {
-            throw new Error('Current user not found! Not logged in?')
+            throw new Error("Current user not found! Not logged in?");
         }
-        await store.fetcher.load(me.doc())
-        return me
+        await store.fetcher.load(me.doc());
+        return me;
     }
 
     function getPodRoot(user: NamedNode): NamedNode {
-        const podRoot = findStorage(user)
+        const podRoot = findStorage(user);
         if (!podRoot) {
-            throw new Error('User pod root not found!')
+            throw new Error("User pod root not found!");
         }
-        return podRoot as NamedNode
+        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())
+        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!')
+            throw new Error("User main inbox not found!");
         }
-        return mainInbox as NamedNode
+        return mainInbox as NamedNode;
     }
 
     function findStorage(me: NamedNode) {
-        return store.any(me, ns.space('storage'), undefined, me.doc())
+        return store.any(me, ns.space("storage"), undefined, me.doc());
     }
 
     return {

package/src/typeIndex/typeIndexLogic.ts

@@ -1,22 +1,22 @@
 import { NamedNode, st, sym } from 'rdflib'
 import { ScopedApp, TypeIndexLogic, TypeIndexScope } from '../types'
-import * as debug from '../util/debug'
+import * as debug from "../util/debug"
 import { ns as namespace } from '../util/ns'
-import { newThing } from '../util/utils'
+import { newThing } from "../util/utils"
 
 export function createTypeIndexLogic(store, authn, profileLogic, utilityLogic): TypeIndexLogic {
     const ns = namespace
 
     function getRegistrations(instance, theClass) {
         return store
-            .each(undefined, ns.solid('instance'), instance)
+            .each(undefined, ns.solid("instance"), instance)
             .filter((r) => {
-                return store.holds(r, ns.solid('forClass'), theClass)
-            })
+                return store.holds(r, ns.solid("forClass"), theClass);
+            });
     }
 
     async function loadTypeIndexesFor(user: NamedNode): Promise<Array<TypeIndexScope>> {
-        if (!user) throw new Error('loadTypeIndexesFor: No user given')
+        if (!user) throw new Error(`loadTypeIndexesFor: No user given`)
         const profile = await profileLogic.loadProfile(user)
 
         const suggestion = suggestPublicTypeIndex(user)
@@ -46,7 +46,7 @@ export function createTypeIndexLogic(store, authn, profileLogic, utilityLogic):
             let privateTypeIndex
             try {
                 privateTypeIndex = store.any(user, ns.solid('privateTypeIndex'), undefined, profile) ||
-                    await utilityLogic.followOrCreateLink(user, ns.solid('privateTypeIndex') as NamedNode, suggestedPrivateTypeIndex, preferencesFile)
+                    await utilityLogic.followOrCreateLink(user, ns.solid('privateTypeIndex') as NamedNode, suggestedPrivateTypeIndex, preferencesFile);
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
                 } catch (err) {
                 const message = `User ${user} has no pointer in preference file to privateTypeIndex file.`

package/src/types.ts

@@ -1,5 +1,5 @@
-import { Session } from '@inrupt/solid-client-authn-browser'
-import { LiveStore, NamedNode, Statement } from 'rdflib'
+import { Session } from "@inrupt/solid-client-authn-browser"
+import { LiveStore, NamedNode, Statement } from "rdflib"
 
 export type AppDetails = {
     noun: string