solid-logic 3.0.9-ea192f01 → 3.0.9-ed64096

package/src/chat/chatLogic.ts

@@ -1,226 +0,0 @@
-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'
-
-export function createChatLogic(store, profileLogic): ChatLogic {
-    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): Promise<Chat> {
-        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')
-            )
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        } 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

@@ -1,59 +0,0 @@
-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 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<NamedNode[]> {
-      if (!user) {
-        user = await profileLogic.loadMe()
-      }
-      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)
-    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,21 +0,0 @@
-// 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
-
-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 { UnauthorizedError, CrossOriginForbiddenError, SameOriginForbiddenError, NotFoundError, FetchError, NotEditableError, WebOperationError } from './logic/CustomError'
-
-export {
-  solidLogicSingleton, // solidLogicSingleton is exported entirely because it is used in solid-panes
-  store,
-  authn,
-  authSession
-}
-

package/src/issuer/issuerLogic.ts

@@ -1,40 +0,0 @@
-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://login.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

@@ -1,29 +0,0 @@
-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 NotEditableError extends CustomError { }
-
-export class WebOperationError extends CustomError {}
-
-export class FetchError extends CustomError {
-    status: number
-
-    constructor(status: number, message?: string) {
-        super(message)
-        this.status = status
-    }
-}

package/src/logic/solidLogic.ts

@@ -1,76 +0,0 @@
-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
-** into a `ConnectedStore` or a `LiveStore`.  A Fetcher object is
-** available at store.fetcher, and `fetch` function at `store.fetcher._fetch`,
-*/
-// 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.')
-    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
-    store.features = [] // disable automatic node merging on store load
-
-    const authn: AuthnLogic = new SolidAuthnLogic(session)
-    
-    const acl = createAclLogic(store)
-    const containerLogic = createContainerLogic(store)
-    const utilityLogic = createUtilityLogic(store, acl, containerLogic)
-    const profile = createProfileLogic(store, authn, utilityLogic)
-    const chat = createChatLogic(store, profile)
-    const inbox = createInboxLogic(store, profile, utilityLogic, containerLogic, acl)
-    const typeIndex = createTypeIndexLogic(store, authn, profile, utilityLogic)
-    debug.log('SolidAuthnLogic initialized')
-
-    function load(doc: NamedNode | NamedNode[] | string) {
-        return store.fetcher.load(doc)
-    }
-
-    // @@@@ use the one in rdflib.js when it is available and delete this
-    function updatePromise(
-        del: Array<Statement>,
-        ins: Array<Statement> = []
-    ): Promise<void> {
-        return new Promise((resolve, reject) => {
-        store.updater.update(del, ins, function (_uri, ok, errorBody) {
-            if (!ok) {
-            reject(new Error(errorBody))
-            } else {
-            resolve()
-            }
-        }) // callback
-        }) // promise
-    }
-
-    function clearStore() {
-        store.statements.slice().forEach(store.remove.bind(store))
-    }
-
-    return {
-        store,
-        authn,
-        acl,
-        inbox,
-        chat,
-        profile,
-        typeIndex,
-        load,
-        updatePromise,
-        clearStore
-    }
-}

package/src/logic/solidLogicSingleton.ts

@@ -1,20 +0,0 @@
-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'
-    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)
-    }
-}
-
-//this const makes solidLogicSingleton global accessible in mashlib
-const solidLogicSingleton = createSolidLogic({ fetch: _fetch }, authSession)
-
-debug.log('Unique quadstore initialized.')
-
-export { solidLogicSingleton }

package/src/profile/profileLogic.ts

@@ -1,125 +0,0 @@
-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
-
-    /**
-     * 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)
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        } 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
-        }
-
-        try {
-            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 {
-        loadMe,
-        getPodRoot,
-        getMainInbox,
-        findStorage,
-        loadPreferences,
-        loadProfile,
-        silencedLoadPreferences
-    }
-}