solid-logic 1.3.17-f7bdc345 → 2.0.0

package/src/types.ts

@@ -1,5 +1,5 @@
 import { Session } from "@inrupt/solid-client-authn-browser"
-import { NamedNode } from "rdflib"
+import { LiveStore, NamedNode, Statement } from "rdflib"
 
 export type AppDetails = {
     noun: string
@@ -32,12 +32,91 @@ export interface SolidNamespace {
     [key: string]: (term: string) => NamedNode
 }
 
-interface NewPaneOptions {
+export type TypeIndexScope = { label: string, index: NamedNode, agent: NamedNode }
+export type ScopedApp = { instance: NamedNode, scope: TypeIndexScope }
+
+export interface NewPaneOptions {
     me?: NamedNode;
     newInstance?: NamedNode;
     newBase: string;
 }
 
-interface CreatedPaneOptions {
+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: string) => Promise<any>,
+    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<string[]>,
+    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>,
+    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/containerLogic.ts

@@ -0,0 +1,54 @@
+import { NamedNode, Statement, sym } from "rdflib";
+
+/**
+ * Container-related class
+ */
+export function createContainerLogic(store) {
+
+    function getContainerElements(containerNode: NamedNode): NamedNode[] {
+            return store
+                .statementsMatching(
+                    containerNode,
+                    sym("http://www.w3.org/ns/ldp#contains"),
+                    undefined,
+                    containerNode.doc()
+                )
+                .map((st: Statement) => st.object as NamedNode);
+    }
+
+    function isContainer(url: string) {
+            return url.charAt(url.length - 1) === "/";
+    }
+
+    async function createContainer(url: string) {
+            if (!isContainer(url)) {
+                throw new Error(`Not a container URL ${url}`);
+            }
+            // Copied from https://github.com/solidos/solid-crud-tests/blob/v3.1.0/test/surface/create-container.test.ts#L56-L64
+            const result = await store.fetcher._fetch(url, {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "text/turtle",
+                    "If-None-Match": "*",
+                    Link: '<http://www.w3.org/ns/ldp#BasicContainer>; rel="type"', // See https://github.com/solidos/node-solid-server/issues/1465
+                },
+                body: " ", // work around https://github.com/michielbdejong/community-server/issues/4#issuecomment-776222863
+            });
+            if (result.status.toString()[0] !== '2') {
+                throw new Error(`Not OK: got ${result.status} response while creating container at ${url}`);
+            }
+    }
+
+    async function getContainerMembers(containerUrl: string): Promise<string[]> {
+            const containerNode = store.sym(containerUrl);
+            await store.fetcher.load(containerNode);
+            const nodes = getContainerElements(containerNode);
+            return nodes.map(node => node.value);
+    }
+    return {
+        isContainer,
+        createContainer,
+        getContainerElements,
+        getContainerMembers
+    }
+}

package/src/util/ns.ts

@@ -0,0 +1,5 @@
+// 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

@@ -0,0 +1,155 @@
+import { NamedNode, st } 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(url: string) {
+      try {
+        if (containerLogic.isContainer(url)) {
+          const aclDocUrl = await aclLogic.findAclDocUrl(url);
+          await store.fetcher._fetch(aclDocUrl, { method: "DELETE" });
+          const containerMembers = await containerLogic.getContainerMembers(url);
+          await Promise.all(
+            containerMembers.map((url) => recursiveDelete(url))
+          );
+        }
+        return store.fetcher._fetch(url, { method: "DELETE" });
+      } catch (e) {
+        // debug.log(`Please manually remove ${url} from your system under test.`, 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(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

@@ -0,0 +1,52 @@
+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,12 +1,21 @@
-import { sym } from 'rdflib'
-import { setACLUserPublic } from '../src/acl/aclLogic' 
+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(setACLUserPublic).toBeInstanceOf(Function)
+        expect(aclLogic.setACLUserPublic).toBeInstanceOf(Function)
     })
     it.skip('runs', async () => {
-        expect(await setACLUserPublic(
+        expect(await aclLogic.setACLUserPublic(
         'https://test.test#',
         sym('https://test.test#'),
         {}