solid-logic 3.0.9-f51524a8 → 3.0.9-ff53d0a

package/rollup.config.js

@@ -1,29 +0,0 @@
-import resolve from '@rollup/plugin-node-resolve'
-import commonjs from '@rollup/plugin-commonjs'
-import typescript from '@rollup/plugin-typescript'
-import { terser } from 'rollup-plugin-terser'
-import fs from 'fs'
-import json from '@rollup/plugin-json'
-
-const license = fs.readFileSync('./LICENSE', 'utf8')
-
-export default {
-  input: 'src/index.ts',
-  output: {
-    file: 'lib/solid-logic.js',
-    format: 'esm',
-    banner: `/*!\n${license}\n*/`,
-    sourcemap: true
-  },
-  plugins: [
-    resolve({ preferBuiltins: true }), // best practice to be true, chooses node.js buildins
-    commonjs(),
-    typescript({
-      declaration: false, // this is false so it does not generate types for the versionInfo file
-      declarationMap: false
-    }),
-    json(),
-    terser()
-  ],
-  inlineDynamicImports: true // dissables multiple chunk creation, why we use rollup in the first place
-}

package/src/acl/aclLogic.ts

@@ -1,156 +0,0 @@
-import { graph, NamedNode, Namespace, serialize, sym } from 'rdflib'
-import { AclLogic } from '../types'
-import { ns as namespace } from '../util/ns'
-
-
-export const ACL_LINK = sym(
-    'http://www.iana.org/assignments/link-relations/acl'
-)
-
-export function createAclLogic(store): AclLogic {
-
-    const ns = namespace
-    
-    async function findAclDocUrl(url: NamedNode) {
-        await store.fetcher.load(url)
-        const docNode = store.any(url, ACL_LINK)
-        if (!docNode) {
-            throw new Error(`No ACL link discovered for ${url}`)
-        }
-        return docNode.value
-    }
-    /**
-     * 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?: []
-    }
-    ): Promise<NamedNode> {
-    const aclDoc = store.any(
-        store.sym(docURI),
-        ACL_LINK
-    )
-
-    return Promise.resolve()
-        .then(() => {
-        if (aclDoc) {
-            return aclDoc as NamedNode
-        }
-
-        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)
-            }
-
-            return aclDoc
-            })
-        })
-    }
-
-    /**
-     * @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')
-        }
-
-        return fetcher.load(docURI).then(result => {
-            if (!result.ok) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                throw new Error('fetchACLRel: While loading:' + (result as any).error)
-            }
-
-            const aclDoc = store.any(
-            store.sym(docURI),
-            ACL_LINK
-            )
-
-            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
-     */
-    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
-            }
-        }
-        return serialize(acl, g, aclURI)
-    }
-    return {
-        findAclDocUrl,
-        setACLUserPublic,
-        genACLText
-    }
-}

package/src/authSession/authSession.ts

@@ -1,13 +0,0 @@
-import {
-  Session,
-  getClientAuthenticationWithDependencies
-} from '@inrupt/solid-client-authn-browser'
-
-export const authSession = new Session(
-    {
-      clientAuthentication: getClientAuthenticationWithDependencies({})
-    },
-    'mySession'
-  )
-
-  

package/src/authn/SolidAuthnLogic.ts

@@ -1,126 +0,0 @@
-import { namedNode, NamedNode, sym } from 'rdflib'
-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
-
-  constructor(solidAuthSession: Session) {
-    this.session = solidAuthSession
-  }
-
-  // we created authSession getter because we want to access it as authn.authSession externally
-  get authSession():Session { return this.session }
-
-  currentUser(): NamedNode | null {
-    const app = appContext()
-    if (app.viewingNoAuthPage) {
-      return sym(app.webId)
-    }
-    if (this && this.session && this.session.info && this.session.info.webId && this.session.info.isLoggedIn) {
-      return sym(this.session.info.webId)
-    }
-    return offlineTestID() // null unless testing
-  }
-
-  /**
-   * Retrieves currently logged in webId from either
-   * defaultTestUser or SolidAuth
-   * Also activates a session after login
-   * @param [setUserCallback] Optional callback
-   * @returns Resolves with webId uri, if no callback provided
-   */
-  async checkUser<T> (
-    setUserCallback?: (me: NamedNode | null) => T
-  ): Promise<NamedNode | T | null> {
-    // Save hash for "restorePreviousSession"
-    const preLoginRedirectHash = new URL(window.location.href).hash
-    if (preLoginRedirectHash) {
-      window.localStorage.setItem('preLoginRedirectHash', preLoginRedirectHash)
-    }
-    this.session.onSessionRestore((url) => {
-      if (document.location.toString() !== url) history.replaceState(null, '', url)
-    })
-
-    /**
-     * Handle a successful authentication redirect
-     */
-    const redirectUrl = new URL(window.location.href)
-    redirectUrl.hash = ''
-    await this.session
-      .handleIncomingRedirect({
-        restorePreviousSession: true,
-        url: redirectUrl.href
-      })
-
-    // Check to see if a hash was stored in local storage
-    const postLoginRedirectHash = window.localStorage.getItem('preLoginRedirectHash')
-    if (postLoginRedirectHash) {
-      const curUrl = new URL(window.location.href)
-      if (curUrl.hash !== postLoginRedirectHash) {
-        if (history.pushState) {
-          // debug.log('Setting window.location.has using pushState')
-          history.pushState(null, document.title, postLoginRedirectHash)
-        } else {
-          // debug.warn('Setting window.location.has using location.hash')
-          location.hash = postLoginRedirectHash
-        }
-        curUrl.hash = postLoginRedirectHash
-      }
-      // See https://stackoverflow.com/questions/3870057/how-can-i-update-window-location-hash-without-jumping-the-document
-      // window.location.href = curUrl.toString()// @@ See https://developer.mozilla.org/en-US/docs/Web/API/Window/location
-      window.localStorage.setItem('preLoginRedirectHash', '')
-    }
-
-    // Check to see if already logged in / have the WebID
-    let me = offlineTestID()
-    if (me) {
-      return Promise.resolve(setUserCallback ? setUserCallback(me) : me)
-    }
-
-    const webId = this.webIdFromSession(this.session.info)
-    if (webId) {
-      me = this.saveUser(webId)
-    }
-
-    if (me) {
-      debug.log(`(Logged in as ${me} by authentication)`)
-    }
-
-    return Promise.resolve(setUserCallback ? setUserCallback(me) : me)
-  }
-
-  /**
-   * Saves `webId` in `context.me`
-   * @param webId
-   * @param context
-   *
-   * @returns Returns the WebID, after setting it
-   */
-  saveUser (
-    webId: NamedNode | string | null,
-    context?: AuthenticationContext
-  ): NamedNode | null {
-    let webIdUri: string
-    if (webId) {
-      webIdUri = (typeof webId === 'string') ? webId : webId.uri
-      const me = namedNode(webIdUri)
-      if (context) {
-        context.me = me
-      }
-      return me
-    }
-    return null
-  }
-
-  /**
-   * @returns {Promise<string|null>} Resolves with WebID URI or null
-   */
-  webIdFromSession (session?: { webId?: string, isLoggedIn: boolean }): string | null {
-    const webId = session?.webId && session.isLoggedIn ? session.webId : null
-    return webId
-  }
-
-}

package/src/authn/authUtil.ts

@@ -1,70 +0,0 @@
-import { NamedNode, sym } from 'rdflib'
-import * as debug from '../util/debug'
-
-/**
- * find a user or app's context as set in window.SolidAppContext
- * this is a const, not a function, because we have problems to jest mock it otherwise
- * see: https://github.com/facebook/jest/issues/936#issuecomment-545080082 for more
- * @return {any} - an appContext object
- */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const appContext = ():any => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let { SolidAppContext }: any = window
-    SolidAppContext ||= {}
-    SolidAppContext.viewingNoAuthPage = false
-    if (SolidAppContext.noAuth && window.document) {
-        const currentPage = window.document.location.href
-        if (currentPage.startsWith(SolidAppContext.noAuth)) {
-        SolidAppContext.viewingNoAuthPage = true
-        const params = new URLSearchParams(window.document.location.search)
-        if (params) {
-            let viewedPage = SolidAppContext.viewedPage = params.get('uri') || null
-            if (viewedPage) {
-            viewedPage = decodeURI(viewedPage)
-            if (!viewedPage.startsWith(SolidAppContext.noAuth)) {
-                const ary = viewedPage.split(/\//)
-                SolidAppContext.idp = ary[0] + '//' + ary[2]
-                SolidAppContext.viewingNoAuthPage = false
-            }
-            }
-        }
-        }
-    }
-    return SolidAppContext
-}
-
-/**
- * Returns `sym($SolidTestEnvironment.username)` if
- * `$SolidTestEnvironment.username` is defined as a global
- * or 
- * returns testID defined in the HTML page
- * @returns {NamedNode|null}
- */
-export function offlineTestID (): NamedNode | null {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any 
-    const { $SolidTestEnvironment }: any = window
-    if (
-      typeof $SolidTestEnvironment !== 'undefined' &&
-      $SolidTestEnvironment.username
-    ) {
-      // Test setup
-      debug.log('Assuming the user is ' + $SolidTestEnvironment.username)
-      return sym($SolidTestEnvironment.username)
-    }
-    // hack that makes SolidOS work in offline mode by adding the webId directly in html
-    // example usage: https://github.com/solidos/mashlib/blob/29b8b53c46bf02e0e219f0bacd51b0e9951001dd/test/contact/local.html#L37
-    if (
-      typeof document !== 'undefined' &&
-      document.location &&
-      ('' + document.location).slice(0, 16) === 'http://localhost'
-    ) {
-      const div = document.getElementById('appTarget')
-      if (!div) return null
-      const id = div.getAttribute('testID')
-      if (!id) return null
-      debug.log('Assuming user is ' + id)
-      return sym(id)
-    }
-    return null
-}

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