solid-logic 3.1.1-f0ed025 → 3.1.1-f480b7d

package/src/typeIndex/typeIndexLogic.ts

@@ -1,198 +0,0 @@
-import { NamedNode, st, sym } from 'rdflib'
-import { ScopedApp, TypeIndexLogic, TypeIndexScope } from '../types'
-import * as debug from "../util/debug"
-import { ns as namespace } from '../util/ns'
-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)
-            .filter((r) => {
-                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`)
-        const profile = await profileLogic.loadProfile(user)
-
-        const suggestion = suggestPublicTypeIndex(user)
-        let publicTypeIndex
-        try {
-            publicTypeIndex = await utilityLogic.followOrCreateLink(user, ns.solid('publicTypeIndex') as NamedNode, suggestion, profile)
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        } catch (err) {
-            const message = `User ${user} has no pointer in profile to publicTypeIndex file.`
-            debug.warn(message)
-        }
-        const publicScopes = publicTypeIndex ? [{ label: 'public', index: publicTypeIndex as NamedNode, agent: user }] : []
-
-        let preferencesFile
-        try {
-            preferencesFile = await profileLogic.silencedLoadPreferences(user)
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        } catch (err) {
-            preferencesFile = null
-        }
-
-        let privateScopes
-        if (preferencesFile) { // watch out - can be in either as spec was not clear.  Legacy is profile.
-            // If there is a legacy one linked from the profile, use that.
-            // Otherwiae use or make one linked from Preferences
-            const suggestedPrivateTypeIndex = suggestPrivateTypeIndex(preferencesFile)
-            let privateTypeIndex
-            try {
-                privateTypeIndex = store.any(user, ns.solid('privateTypeIndex'), undefined, profile) ||
-                    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.`
-                debug.warn(message)
-            }
-            privateScopes = privateTypeIndex ? [{ label: 'private', index: privateTypeIndex as NamedNode, agent: user }] : []
-        } else {
-            privateScopes = []
-        }
-        const scopes = publicScopes.concat(privateScopes)
-        if (scopes.length === 0) return scopes
-        const files = scopes.map(scope => scope.index)
-        try {
-            await store.fetcher.load(files)
-        } catch (err) {
-            debug.warn('Problems loading type index: ', err)
-        }
-        return scopes
-    }
-
-    async function loadCommunityTypeIndexes(user: NamedNode): Promise<TypeIndexScope[][]> {
-        let preferencesFile
-        try {
-            preferencesFile = await profileLogic.silencedLoadPreferences(user)
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        } catch (err) {
-            const message = `User ${user} has no pointer in profile to preferences file.`
-            debug.warn(message)
-        }
-        if (preferencesFile) { // For now, pick up communities as simple links from the preferences file.
-            const communities = store.each(user, ns.solid('community'), undefined, preferencesFile as NamedNode).concat(
-                store.each(user, ns.solid('community'), undefined, user.doc() as NamedNode)
-            )
-            let result = []
-            for (const org of communities) {
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                result = result.concat(await loadTypeIndexesFor(org as NamedNode) as any)
-            }
-            return result
-        }
-        return [] // No communities
-    }
-
-    async function loadAllTypeIndexes(user: NamedNode) {
-        return (await loadTypeIndexesFor(user)).concat((await loadCommunityTypeIndexes(user)).flat())
-    }
-
-    async function getScopedAppInstances(klass: NamedNode, user: NamedNode): Promise<ScopedApp[]> {
-        const scopes = await loadAllTypeIndexes(user)
-        let scopedApps = []
-        for (const scope of scopes) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const scopedApps0 = await getScopedAppsFromIndex(scope, klass) as any
-            scopedApps = scopedApps.concat(scopedApps0)
-        }
-        return scopedApps
-    }
-
-    // This is the function signature which used to be in solid-ui/logic
-    // Recommended to use getScopedAppInstances instead as it provides more information.
-    //
-    async function getAppInstances(klass: NamedNode): Promise<NamedNode[]> {
-        const user = authn.currentUser()
-        if (!user) throw new Error('getAppInstances: Must be logged in to find apps.')
-        const scopedAppInstances = await getScopedAppInstances(klass, user)
-        return scopedAppInstances.map(scoped => scoped.instance)
-    }
-
-    function suggestPublicTypeIndex(me: NamedNode) {
-        return sym(me.doc().dir()?.uri + 'publicTypeIndex.ttl')
-    }
-    // Note this one is based off the pref file not the profile
-
-    function suggestPrivateTypeIndex(preferencesFile: NamedNode) {
-        return sym(preferencesFile.doc().dir()?.uri + 'privateTypeIndex.ttl')
-    }
-
-    /*
-    * Register a new app in a type index
-    * used in chat in bookmark.js (solid-ui)
-    * Returns the registration object if successful else null
-    */
-    async function registerInTypeIndex(
-        instance: NamedNode,
-        index: NamedNode,
-        theClass: NamedNode,
-        // agent: NamedNode
-    ): Promise<NamedNode | null> {
-        const registration = newThing(index)
-        const ins = [
-            // See https://github.com/solid/solid/blob/main/proposals/data-discovery.md
-            st(registration, ns.rdf('type'), ns.solid('TypeRegistration'), index),
-            st(registration, ns.solid('forClass'), theClass, index),
-            st(registration, ns.solid('instance'), instance, index)
-        ]
-        try {
-            await store.updater.update([], ins)
-        } catch (err) {
-            const msg = `Unable to register ${instance} in index ${index}: ${err}`
-            console.warn(msg)
-            return null
-        }
-        return registration
-    }
-
-    async function deleteTypeIndexRegistration(item) {
-        const reg = store.the(null, ns.solid('instance'), item.instance, item.scope.index) as NamedNode
-        if (!reg) throw new Error(`deleteTypeIndexRegistration: No registration found for ${item.instance}`)
-        const statements = store.statementsMatching(reg, null, null, item.scope.index)
-        await store.updater.update(statements, [])
-    }
-
-    async function getScopedAppsFromIndex(scope: TypeIndexScope, theClass: NamedNode | null): Promise<ScopedApp[]> {
-        const index = scope.index
-        const results: ScopedApp[] = []
-        const registrations = store.statementsMatching(null, ns.solid('instance'), null, index)
-            .concat(store.statementsMatching(null, ns.solid('instanceContainer'), null, index))
-            .map(st => st.subject)
-        for (const reg of registrations) {
-          const klass = store.any(reg, ns.solid('forClass'), null, index)
-          if (!theClass || klass.sameTerm(theClass)) {
-            const instances = store.each(reg, ns.solid('instance'), null, index)
-            for (const instance of instances) {
-              results.push({ instance, type: klass, scope })
-            }
-            const containers = store.each(reg, ns.solid('instanceContainer'), null, index)
-            for (const instance of containers) {
-                await store.fetcher.load(instance)
-                results.push({ instance: sym(instance.value), type: klass,  scope })
-            }
-          }
-        }
-        return results
-    }
-
-    return {
-        registerInTypeIndex,
-        getRegistrations,
-        loadTypeIndexesFor,
-        loadCommunityTypeIndexes,
-        loadAllTypeIndexes,
-        getScopedAppInstances,
-        getAppInstances,
-        suggestPublicTypeIndex,
-        suggestPrivateTypeIndex,
-        deleteTypeIndexRegistration,
-        getScopedAppsFromIndex
-    }
-}

package/src/types.ts

@@ -1,122 +0,0 @@
-import { Session } from "@inrupt/solid-client-authn-browser"
-import { LiveStore, NamedNode, Statement } from "rdflib"
-
-export type AppDetails = {
-    noun: string
-    appPathSegment: string
-}
-
-export type AuthenticationContext = {
-    containers?: Array<NamedNode>
-    div?: HTMLElement
-    dom?: HTMLDocument
-    index?: { [key: string]: Array<NamedNode> }
-    instances?: Array<NamedNode>
-    me?: NamedNode | null
-    noun?: string
-    preferencesFile?: NamedNode
-    preferencesFileError?: string
-    publicProfile?: NamedNode
-    statusArea?: HTMLElement
-}
-
-export interface AuthnLogic {
-    authSession: Session //this needs to be deprecated in the future. Is only here to allow imports like panes.UI.authn.authSession prior to moving authn from ui to logic
-    currentUser: () => NamedNode | null
-    checkUser: <T>(setUserCallback?: (me: NamedNode | null) => T) => Promise<NamedNode | T | null>
-    saveUser: (webId: NamedNode | string | null,
-        context?: AuthenticationContext) => NamedNode | null
-}
-
-export interface SolidNamespace {
-    [key: string]: (term: string) => NamedNode
-}
-
-export type TypeIndexScope = { label: string, index: NamedNode, agent: NamedNode }
-export type ScopedApp = { instance: NamedNode, type: NamedNode, scope: TypeIndexScope }
-
-export interface NewPaneOptions {
-    me?: NamedNode;
-    newInstance?: NamedNode;
-    newBase: string;
-}
-
-export interface CreatedPaneOptions {
-newInstance: NamedNode;
-}
-
-export interface ChatLogic {
-    setAcl: (chatContainer: NamedNode, me: NamedNode, invitee: NamedNode) => Promise<void>,
-    addToPrivateTypeIndex: (chatThing, me) => void | Promise<void>,
-    findChat: (invitee: NamedNode) => Promise<Chat>,
-    createChatThing: (chatContainer: NamedNode, me: NamedNode) => Promise<NamedNode>,
-    mintNew: (newPaneOptions: NewPaneOptions) => Promise<CreatedPaneOptions>,
-    getChat: (invitee: NamedNode, boolean) => Promise<NamedNode | null>,
-    sendInvite: (invitee: NamedNode, chatThing: NamedNode) => void
-}
-
-export interface Chat {
-    me: NamedNode,
-    chatContainer: NamedNode,
-    exists: boolean
-}
-
-export interface ProfileLogic {
-    silencedLoadPreferences: (user: NamedNode) => Promise<NamedNode | undefined>,
-    loadPreferences: (user: NamedNode) => Promise<NamedNode>,
-    loadProfile: (user: NamedNode) => Promise<NamedNode>,
-    loadMe: () => Promise<NamedNode>,
-    getPodRoot: (user: NamedNode) => NamedNode,
-    getMainInbox: (user: NamedNode) => Promise<NamedNode>,
-    findStorage: (me: NamedNode) => Node | null
-}
-
-export interface AclLogic {
-    findAclDocUrl: (url: NamedNode) => Promise<string | undefined>,
-    setACLUserPublic: (docURI: string, me: NamedNode,
-        options: {
-            defaultForNew?: boolean,
-            public?: []
-        }
-    ) => Promise<NamedNode>,
-    genACLText: (docURI: string, me: NamedNode, aclURI: string,
-        options: {
-            defaultForNew?: boolean,
-            public?: []
-        }
-    ) => string | undefined
-}
-
-export interface InboxLogic {
-    createInboxFor: (peerWebId: string, nick: string) => Promise<string>,
-    getNewMessages: (user?: NamedNode) => Promise<NamedNode[]>,
-    markAsRead: (url: string, date: Date) => void
-}
-
-export interface TypeIndexLogic {
-    getRegistrations: (instance, theClass) => Node[],
-    loadTypeIndexesFor: (user: NamedNode) => Promise<Array<TypeIndexScope>>,
-    loadCommunityTypeIndexes: (user: NamedNode) => Promise<TypeIndexScope[][]>,
-    loadAllTypeIndexes: (user: NamedNode) => Promise<Array<TypeIndexScope>>,
-    getScopedAppInstances: (klass: NamedNode, user: NamedNode) => Promise<ScopedApp[]>,
-    getAppInstances: (klass: NamedNode) => Promise<NamedNode[]>,
-    suggestPublicTypeIndex: (me: NamedNode) => NamedNode,
-    suggestPrivateTypeIndex: (preferencesFile: NamedNode) => NamedNode,
-    registerInTypeIndex: (instance: NamedNode, index: NamedNode, theClass: NamedNode) => Promise<NamedNode | null>,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    deleteTypeIndexRegistration: (item: any) => Promise<void>
-    getScopedAppsFromIndex: (scope: TypeIndexScope, theClass: NamedNode | null) => Promise<ScopedApp[]>
-}
-
-export interface SolidLogic {
-    store: LiveStore,
-    authn: AuthnLogic,
-    acl: AclLogic,
-    profile: ProfileLogic,
-    inbox: InboxLogic,
-    typeIndex: TypeIndexLogic,
-    chat: ChatLogic,
-    load: (doc: NamedNode | NamedNode[] | string) => void,
-    updatePromise: (del: Array<Statement>, ins: Array<Statement>) => Promise<void>,
-    clearStore: () => void
-}

package/src/util/debug.ts

@@ -1,20 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export function log(...args: any[]): void {
-  // eslint-disable-next-line no-console
-  console.log(...args);
-}
-
-export function warn(...args: any[]): void {
-  // eslint-disable-next-line no-console
-  console.warn(...args);
-}
-
-export function error(...args: any[]): void {
-  // eslint-disable-next-line no-console
-  console.error(...args);
-}
-
-export function trace(...args: any[]): void {
-  // eslint-disable-next-line no-console
-  console.trace(...args);
-}

package/src/util/ns.ts

@@ -1,5 +0,0 @@
-// Namespaces we commonly use and have common prefixes for around Solid
-import solidNamespace from 'solid-namespace' // Delegate to this which takes RDFlib as param.
-import * as $rdf from 'rdflib'
-
-export const ns = solidNamespace($rdf)

package/src/util/utilityLogic.ts

@@ -1,156 +0,0 @@
-import { NamedNode, st, sym } from "rdflib";
-import { CrossOriginForbiddenError, FetchError, NotEditableError, SameOriginForbiddenError, UnauthorizedError, WebOperationError } from "../logic/CustomError";
-import * as debug from '../util/debug';
-import { differentOrigin } from "./utils";
-
-export function createUtilityLogic(store, aclLogic, containerLogic) {
-
-  async function recursiveDelete(containerNode: NamedNode) {
-      try {
-        if (containerLogic.isContainer(containerNode)) {
-          const aclDocUrl = await aclLogic.findAclDocUrl(containerNode)
-          await store.fetcher._fetch(aclDocUrl, { method: "DELETE" });
-          const containerMembers = await containerLogic.getContainerMembers(containerNode);
-          await Promise.all(
-            containerMembers.map((url) => recursiveDelete(url))
-          );
-        }
-        const nodeToStringHere = containerNode.value;
-        return store.fetcher._fetch(nodeToStringHere, { method: "DELETE" })
-      } catch (e) {
-        debug.log(`Please manually remove ${containerNode.value} from your system.`, e);
-      }
-  }
-
-  /**
-   * Create a resource if it really does not exist
-   * Be absolutely sure something does not exist before creating a new empty file
-   * as otherwise existing could  be deleted.
-   * @param doc {NamedNode} - The resource
-   */
-  async function loadOrCreateIfNotExists(doc: NamedNode) {
-    let response
-    try {
-      response = await store.fetcher.load(doc)
-    } catch (err) {
-      if (err.response.status === 404) {
-        try {
-          await store.fetcher.webOperation('PUT', doc, { data: '', contentType: 'text/turtle' })
-        } catch (err) {
-          const msg = 'createIfNotExists: PUT FAILED: ' + doc + ': ' + err
-          throw new WebOperationError(msg)
-        }
-        await store.fetcher.load(doc)
-      } else {
-        if (err.response.status === 401) {
-          throw new UnauthorizedError();
-        }
-        if (err.response.status === 403) {
-          if (differentOrigin(doc)) {
-            throw new CrossOriginForbiddenError();
-          }
-          throw new SameOriginForbiddenError();
-        }
-        const msg = 'createIfNotExists doc load error NOT 404:  ' + doc + ': ' + err
-        throw new FetchError(err.status, err.message + msg)
-      }
-    }
-    return response
-  }
-
-  /* Follow link from this doc to another thing, or else make a new link
-  **
-  ** @returns existing object, or creates it if non existent
-  */
-  async function followOrCreateLink(subject: NamedNode, predicate: NamedNode,
-    object: NamedNode, doc: NamedNode
-  ): Promise<NamedNode | null> {
-    await store.fetcher.load(doc)
-    const result = store.any(subject, predicate, null, doc)
-
-    if (result) return result as NamedNode
-    if (!store.updater.editable(doc)) {
-      const msg = `followOrCreateLink: cannot edit ${doc.value}`
-      debug.warn(msg)
-      throw new NotEditableError(msg)
-    }
-    try {
-      await store.updater.update([], [st(subject, predicate, object, doc)])
-    } catch (err) {
-      const msg = `followOrCreateLink: Error making link in ${doc} to ${object}: ${err}`
-      debug.warn(msg)
-      throw new WebOperationError(err)
-    }
-
-    try {
-      await loadOrCreateIfNotExists(object)
-      // store.fetcher.webOperation('PUT', object, { data: '', contentType: 'text/turtle'})
-    } catch (err) {
-      debug.warn(`followOrCreateLink: Error loading or saving new linked document: ${object}: ${err}`)
-      throw err;
-    }
-    return object
-  }
-
-  // Copied from https://github.com/solidos/web-access-control-tests/blob/v3.0.0/test/surface/delete.test.ts#L5
-  async function setSinglePeerAccess(options: {
-    ownerWebId: string,
-    peerWebId: string,
-    accessToModes?: string,
-    defaultModes?: string,
-    target: string
-  }) {
-    let str = [
-      '@prefix acl: <http://www.w3.org/ns/auth/acl#>.',
-      '',
-      `<#alice> a acl:Authorization;\n  acl:agent <${options.ownerWebId}>;`,
-      `  acl:accessTo <${options.target}>;`,
-      `  acl:default <${options.target}>;`,
-      '  acl:mode acl:Read, acl:Write, acl:Control.',
-      ''
-    ].join('\n')
-    if (options.accessToModes) {
-      str += [
-        '<#bobAccessTo> a acl:Authorization;',
-        `  acl:agent <${options.peerWebId}>;`,
-        `  acl:accessTo <${options.target}>;`,
-        `  acl:mode ${options.accessToModes}.`,
-        ''
-      ].join('\n')
-    }
-    if (options.defaultModes) {
-      str += [
-        '<#bobDefault> a acl:Authorization;',
-        `  acl:agent <${options.peerWebId}>;`,
-        `  acl:default <${options.target}>;`,
-        `  acl:mode ${options.defaultModes}.`,
-        ''
-      ].join('\n')
-    }
-    const aclDocUrl = await aclLogic.findAclDocUrl(sym(options.target))
-    return store.fetcher._fetch(aclDocUrl, {
-      method: 'PUT',
-      body: str,
-      headers: [
-        ['Content-Type', 'text/turtle']
-      ]
-    });
-  }
-
-  async function createEmptyRdfDoc(doc: NamedNode, comment: string) {
-    await store.fetcher.webOperation("PUT", doc.uri, {
-      data: `# ${new Date()} ${comment}
-  `,
-      contentType: "text/turtle",
-    });
-  }
-  
-  return {
-    recursiveDelete,
-    setSinglePeerAccess,
-    createEmptyRdfDoc,
-    followOrCreateLink,
-    loadOrCreateIfNotExists
-  }
-}
-

package/src/util/utils.ts

@@ -1,52 +0,0 @@
-import { NamedNode, sym } from "rdflib";
-
-export function newThing(doc: NamedNode): NamedNode {
-    return sym(doc.uri + "#" + "id" + ("" + Date.now()));
-}
-
-export function uniqueNodes (arr: NamedNode[]): NamedNode[] {
-    const uris = arr.map(x => x.uri)
-    const set = new Set(uris)
-    const uris2 = Array.from(set)
-    const arr2 = uris2.map(u => new NamedNode(u))
-    return arr2 // Array.from(new Set(arr.map(x => x.uri))).map(u => sym(u))
-}
-
-export function getArchiveUrl(baseUrl: string, date: Date) {
-    const year = date.getUTCFullYear();
-    const month = ('0' + (date.getUTCMonth()+1)).slice(-2);
-    const day = ('0' + (date.getUTCDate())).slice(-2);
-    const parts = baseUrl.split('/');
-    const filename = parts[parts.length -1 ];
-    return new URL(`./archive/${year}/${month}/${day}/${filename}`, baseUrl).toString();
-}
-
-export function differentOrigin(doc): boolean {
-    if (!doc) {
-        return true;
-    }
-    return (
-        `${window.location.origin}/` !== new URL(doc.value).origin
-    );
-}
-
-export function suggestPreferencesFile (me:NamedNode) {
-    const stripped = me.uri.replace('/profile/', '/').replace('/public/', '/')
-    // const stripped = me.uri.replace(\/[p|P]rofile/\g, '/').replace(\/[p|P]ublic/\g, '/')
-    const folderURI = stripped.split('/').slice(0,-1).join('/') + '/Settings/'
-    const fileURI = folderURI + 'Preferences.ttl'
-    return sym(fileURI)
-}
-
-export function determineChatContainer(
-    invitee: NamedNode,
-    podRoot: NamedNode
-): NamedNode {
-    // Create chat
-    // See https://gitter.im/solid/chat-app?at=5f3c800f855be416a23ae74a
-    const chatContainerStr = new URL(
-        `IndividualChats/${new URL(invitee.value).host}/`,
-        podRoot.value
-    ).toString();
-    return new NamedNode(chatContainerStr);
-}

package/test/aclLogic.test.ts

@@ -1,24 +0,0 @@
-import { Fetcher, Store, sym, UpdateManager } from 'rdflib';
-import { createAclLogic } from '../src/acl/aclLogic';
-
-describe('setACLUserPublic', () => {
-    let aclLogic
-    let store
-    beforeAll(() => {
-        const options = { fetch: fetch };
-        store = new Store()
-        store.fetcher = new Fetcher(store, options);
-        store.updater = new UpdateManager(store);
-        aclLogic = createAclLogic(store)
-    })
-    it('exists', () => {
-        expect(aclLogic.setACLUserPublic).toBeInstanceOf(Function)
-    })
-    it.skip('runs', async () => {
-        expect(await aclLogic.setACLUserPublic(
-        'https://test.test#',
-        sym('https://test.test#'),
-        {}
-        )).toEqual({})
-    })
-})

package/test/authUtil.test.ts

@@ -1,23 +0,0 @@
-/**
-* @jest-environment jsdom
-* 
-*/
-import * as authUtil from '../src/authn/authUtil'
-
-describe('offlineTestID', () => {
-    it('exists', () => {
-        expect(authUtil.offlineTestID).toBeInstanceOf(Function)
-    })
-    it('runs', () => {
-        expect(authUtil.offlineTestID()).toEqual(null)
-    })
-})
-
-describe('appContext', () => {
-    it('exists', () => {
-        expect(authUtil.appContext).toBeInstanceOf(Function)
-    })
-    it('runs', () => {
-        expect(authUtil.appContext()).toEqual({"viewingNoAuthPage": false,})
-    })
-})