solid-logic 3.1.1 → 4.0.0-3818f4f

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

package/src/index.ts

@@ -1,22 +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 { createTypeIndexLogic } from './typeIndex/typeIndexLogic'
-export { 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: 'Solid Web ME',
-    uri: 'https://solidweb.me'
-  },
-  {
-    name: '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
-    }
-}