solid-logic 3.1.1-da65b2c → 3.1.1-e3eba68

package/src/util/utilityLogic.ts

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

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

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

@@ -0,0 +1,23 @@
+/**
+* @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,})
+    })
+})

package/test/chatLogic.test.ts

@@ -0,0 +1,316 @@
+/**
+* @jest-environment jsdom
+*
+*/
+import { UpdateManager, Store, Fetcher } from "rdflib";
+import { createAclLogic } from "../src/acl/aclLogic";
+import { createChatLogic } from '../src/chat/chatLogic';
+import { createProfileLogic } from "../src/profile/profileLogic";
+import { createContainerLogic } from "../src/util/containerLogic";
+import { createUtilityLogic } from "../src/util/utilityLogic";
+import { alice, bob } from "./helpers/dataSetup";
+
+window.$SolidTestEnvironment = { username: alice.uri }
+
+describe("Chat logic", () => {
+  let chatLogic;
+  let store;
+  beforeEach(() => {
+    fetchMock.resetMocks();
+    fetchMock.mockResponse("Not Found", {
+      status: 404,
+    });
+    store = new Store()
+    store.fetcher = new Fetcher(store, { fetch: fetch });
+    store.updater = new UpdateManager(store);
+    const authn = {
+      currentUser: () => {
+        return alice;
+      },
+    };
+    const util = createUtilityLogic(store, createAclLogic(store), createContainerLogic(store))
+    chatLogic = createChatLogic(store, createProfileLogic(store, authn, util))
+  });
+
+  describe("get chat, without creating", () => {
+    describe("when no chat exists yet", () => {
+      let result;
+      beforeEach(async () => {
+        aliceHasValidProfile();
+        noChatWithBobExists();
+        result = await chatLogic.getChat(bob, false);
+      });
+      it("does not return a chat", async () => {
+        expect(result).toBeNull();
+      });
+      it("loaded the current user profile", () => {
+        expect(fetchMock.mock.calls[0][0]).toBe(
+          "https://alice.example.com/profile/card.ttl"
+        );
+      });
+      it("tried to load the chat document", () => {
+        expect(fetchMock.mock.calls[1][0]).toBe(
+          "https://alice.example.com/IndividualChats/bob.example.com/index.ttl"
+        );
+      });
+      it("has no additional fetch requests", () => {
+        expect(fetchMock.mock.calls.length).toBe(2);
+      });
+    });
+  });
+
+  describe("get chat, create if missing", () => {
+    describe("when no chat exists yet", () => {
+      let result;
+      beforeEach(async () => {
+        Date.now = jest.fn(() =>
+          new Date(Date.UTC(2021, 1, 6, 10, 11, 12)).valueOf()
+        );
+        aliceHasValidProfile();
+        noChatWithBobExists();
+        chatWithBobCanBeCreated();
+        bobHasAnInbox();
+        invitationCanBeSent();
+        chatContainerIsFound();
+        chatContainerAclCanBeSet();
+        editablePrivateTypeIndexIsFound();
+        privateTypeIndexIsUpdated();
+        result = await chatLogic.getChat(bob, true);
+      });
+      it("returns the chat URI based on the invitee's WebID", () => {
+        expect(result.uri).toBe(
+          "https://alice.example.com/IndividualChats/bob.example.com/index.ttl#this"
+        );
+      });
+      it("created a chat document", () => {
+        const request = getRequestTo(
+          "PUT",
+          "https://alice.example.com/IndividualChats/bob.example.com/index.ttl"
+        );
+        expect(request.body).toBe(`@prefix : <#>.
+@prefix dc: <http://purl.org/dc/elements/1.1/>.
+@prefix meeting: <http://www.w3.org/ns/pim/meeting#>.
+@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
+@prefix c: </profile/card.ttl#>.
+
+:this
+    a meeting:LongChat;
+    dc:author c:me;
+    dc:created "2021-02-06T10:11:12Z"^^xsd:dateTime;
+    dc:title "Chat channel".
+`);
+      });
+      it("allowed Bob to participate in the chat by adding an ACL", () => {
+        const request = getRequestTo(
+          "PUT",
+          "https://alice.example.com/IndividualChats/bob.example.com/.acl"
+        );
+        expect(request.body).toBe(`
+            @prefix acl: <http://www.w3.org/ns/auth/acl#>.
+            <#owner>
+            a acl:Authorization;
+            acl:agent <https://alice.example.com/profile/card.ttl#me>;
+            acl:accessTo <.>;
+            acl:default <.>;
+            acl:mode
+                acl:Read, acl:Write, acl:Control.
+            <#invitee>
+            a acl:Authorization;
+            acl:agent <https://bob.example.com/profile/card.ttl#me>;
+            acl:accessTo <.>;
+            acl:default <.>;
+            acl:mode
+                acl:Read, acl:Append.
+            `);
+      });
+      it("sent an invitation to invitee inbox", () => {
+        const request = getRequestTo("POST", "https://bob.example.com/inbox");
+        expect(request.body).toContain(`
+        <> a <http://www.w3.org/ns/pim/meeting#LongChatInvite> ;
+        <http://www.w3.org/1999/02/22-rdf-syntax-ns#seeAlso> <https://alice.example.com/IndividualChats/bob.example.com/index.ttl#this> .
+        `);
+      });
+      it("added the new chat to private type index", () => {
+        const request = getRequestTo(
+          "PATCH",
+          "https://alice.example.com/settings/privateTypeIndex.ttl"
+        );
+        expect(request.body)
+          .toBe(`INSERT DATA { <https://alice.example.com/settings/privateTypeIndex.ttl#id1612606272000> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/ns/solid/terms#TypeRegistration> .
+<https://alice.example.com/settings/privateTypeIndex.ttl#id1612606272000> <http://www.w3.org/ns/solid/terms#forClass> <http://www.w3.org/ns/pim/meeting#LongChat> .
+<https://alice.example.com/settings/privateTypeIndex.ttl#id1612606272000> <http://www.w3.org/ns/solid/terms#instance> <https://alice.example.com/IndividualChats/bob.example.com/index.ttl#this> .
+ }
+`);
+      });
+      it("has no additional fetch requests", () => {
+        expect(fetchMock.mock.calls.length).toBe(9);
+      });
+    });
+  });
+
+  describe("possible errors", () => {
+    it("profile does not link to storage", async () => {
+      fetchMock.mockOnceIf("https://alice.example.com/profile/card.ttl", "<><><>.", {
+        headers: {
+          "Content-Type": "text/turtle",
+        },
+      });
+      const expectedError = new Error("User pod root not found!");
+      await expect(chatLogic.getChat(bob, false)).rejects.toEqual(expectedError);
+    });
+
+    it("invitee inbox not found", async () => {
+      aliceHasValidProfile();
+      noChatWithBobExists();
+      chatWithBobCanBeCreated();
+      bobDoesNotHaveAnInbox();
+      const expectedError = new Error(
+        "Invitee inbox not found! https://bob.example.com/profile/card.ttl#me"
+      );
+      await expect(chatLogic.getChat(bob, true)).rejects.toEqual(expectedError);
+    });
+  });
+
+  function aliceHasValidProfile() {
+    fetchMock.mockOnceIf(
+      "https://alice.example.com/profile/card.ttl",
+      `
+            <https://alice.example.com/profile/card.ttl#me>
+              <http://www.w3.org/ns/pim/space#storage> <https://alice.example.com/> ;
+              <http://www.w3.org/ns/solid/terms#privateTypeIndex> <https://alice.example.com/settings/privateTypeIndex.ttl> ;
+            .`,
+      {
+        headers: {
+          "Content-Type": "text/turtle",
+        },
+      }
+    );
+  }
+
+  function noChatWithBobExists() {
+    return fetchMock.mockOnceIf(
+      ({ url, method }) =>
+        url === "https://alice.example.com/IndividualChats/bob.example.com/index.ttl" &&
+        method === "GET",
+      "Not found",
+      {
+        status: 404,
+      }
+    );
+  }
+
+  function chatWithBobCanBeCreated() {
+    return fetchMock.mockOnceIf(
+      ({ url, method }) =>
+        url === "https://alice.example.com/IndividualChats/bob.example.com/index.ttl" &&
+        method === "PUT",
+      "Created",
+      {
+        status: 201,
+      }
+    );
+  }
+
+  function bobHasAnInbox() {
+    fetchMock.mockOnceIf(
+      "https://bob.example.com/profile/card.ttl",
+      "<https://bob.example.com/profile/card.ttl#me><http://www.w3.org/ns/ldp#inbox><https://bob.example.com/inbox>.",
+      {
+        headers: { "Content-Type": "text/turtle" },
+      }
+    );
+  }
+
+  function bobDoesNotHaveAnInbox() {
+    fetchMock.mockOnceIf("https://bob.example.com/profile/card.ttl", "<><><>.", {
+      headers: {
+        "Content-Type": "text/turtle",
+      },
+    });
+  }
+
+  function invitationCanBeSent() {
+    return fetchMock.mockOnceIf(
+      ({ url, method }) =>
+        url === "https://bob.example.com/inbox" && method === "POST",
+      "Created",
+      {
+        status: 201,
+        headers: {
+          location:
+            "https://bob.example.com/inbox/22373339-6cc0-49fc-b69e-0402edda6e4e.ttl",
+        },
+      }
+    );
+  }
+
+  function chatContainerIsFound() {
+    return fetchMock.mockOnceIf(
+      ({ url, method }) =>
+        url === "https://alice.example.com/IndividualChats/bob.example.com/" &&
+        method === "GET",
+      "<><><>.",
+      {
+        status: 200,
+        headers: {
+          "Content-Type": "text/turtle",
+          Link: '<.acl>; rel="acl"',
+        },
+      }
+    );
+  }
+
+  function chatContainerAclCanBeSet() {
+    return fetchMock.mockOnceIf(
+      ({ url, method }) =>
+        url === "https://alice.example.com/IndividualChats/bob.example.com/.acl" &&
+        method === "PUT",
+      "Created",
+      {
+        status: 201,
+      }
+    );
+  }
+
+  function editablePrivateTypeIndexIsFound() {
+    return fetchMock.mockOnceIf(
+      ({ url, method }) =>
+        url === "https://alice.example.com/settings/privateTypeIndex.ttl" &&
+        method === "GET",
+      "<><><>.",
+      {
+        status: 200,
+        headers: {
+          "Content-Type": "text/turtle",
+          "wac-allow": 'user="read write append control",public=""',
+          "ms-author-via": "SPARQL",
+        },
+      }
+    );
+  }
+
+  function privateTypeIndexIsUpdated() {
+    return fetchMock.mockOnceIf(
+      ({ url, method }) =>
+        url === "https://alice.example.com/settings/privateTypeIndex.ttl" &&
+        method === "PATCH",
+      "OK",
+      {
+        status: 200,
+      }
+    );
+  }
+
+  function getRequestTo(
+    method: "GET" | "PUT" | "POST" | "DELETE" | "PATCH",
+    url: string
+  ): RequestInit {
+    const call = fetchMock.mock.calls.find(
+      (it) => it[0] === url && method === it[1]?.method
+    );
+    expect(call).not.toBeNull();
+    const request = call?.[1];
+    expect(request).not.toBeNull();
+    return request!;
+  }
+});

package/test/container.test.ts

@@ -0,0 +1,58 @@
+/**
+* @jest-environment jsdom
+* 
+*/
+import { UpdateManager, Store, Fetcher, sym } from "rdflib";
+import { createContainerLogic } from "../src/util/containerLogic";
+import { alice } from "./helpers/dataSetup";
+
+window.$SolidTestEnvironment = { username: alice.uri }
+
+describe("Container", () => {
+    let store
+    let containerLogic
+    beforeEach(() => {
+        fetchMock.resetMocks()
+        store = new Store()
+        store.fetcher = new Fetcher(store, { fetch: fetch });
+        store.updater = new UpdateManager(store);
+        containerLogic = createContainerLogic(store)
+    })
+
+    it("getContainerMembers - When container has some containment triples", async () => {
+            containerHasSomeContainmentTriples()
+            const containerMembers = await containerLogic.getContainerMembers(sym('https://container.com/'));
+            const result = containerMembers.map(oneResult => oneResult.value)
+            expect(result.sort()).toEqual([
+                'https://container.com/foo.txt',
+                'https://container.com/bar/'
+            ].sort());
+    });
+    it.skip("getContainerMembers- When container is empty - Resolves to an empty array", async () => {
+        jest.setTimeout(2000)
+        containerIsEmpty();
+        const result = await containerLogic.getContainerMembers(sym('https://container.com/'));
+        expect(result).toEqual([]);
+    });
+
+    function containerIsEmpty() {
+        fetchMock.mockOnceIf(
+            "https://com/",
+            "", // FIXME: https://github.com/jefflau/jest-fetch-mock/issues/189
+            {
+                headers: { "Content-Type": "text/turtle" },
+            }
+        );
+    }
+    
+    function containerHasSomeContainmentTriples() {
+        fetchMock.mockOnceIf(
+            "https://container.com/",
+            "<.> <http://www.w3.org/ns/ldp#contains> <./foo.txt>, <./bar/> .",
+            {
+                headers: { "Content-Type": "text/turtle" },
+            }
+        );
+        
+    }
+})