Add CreateActivityHandler and activity paths.

Author: RubenVerborgh

.babelrc

@@ -1,5 +1,12 @@
 {
   presets: [
     ["@babel/env"],
-  ]
+  ],
+  plugins: [
+    ["babel-plugin-inline-import", {
+      extensions: [
+        ".ttl",
+      ],
+    }],
+  ],
 }

package-lock.json

@@ -16,16 +16,18 @@
     "!dist/demo"
   ],
   "dependencies": {
-    "ldflex": "^1.2.0",
-    "ldflex-comunica": "^1.0.0",
-    "solid-auth-client": "^2.2.9"
+    "ldflex": "^1.3.0",
+    "ldflex-comunica": "^1.0.1",
+    "solid-auth-client": "^2.2.9",
+    "uuid": "^3.3.2"
   },
   "devDependencies": {
     "@babel/cli": "^7.0.0",
     "@babel/core": "^7.0.1",
     "@babel/preset-env": "^7.0.0",
     "babel-core": "^7.0.0-bridge.0",
     "babel-loader": "^8.0.2",
+    "babel-plugin-inline-import": "^3.0.0",
     "clean-webpack-plugin": "^0.1.19",
     "copy-webpack-plugin": "^4.5.2",
     "eslint": "^5.6.0",

package.json

@@ -0,0 +1,74 @@
+import auth from 'solid-auth-client';
+import uuid from 'uuid/v4';
+import context from './context.json';
+import { iterablePromise } from 'ldflex';
+import activityTemplate from './activity.ttl';
+
+const { as, xsd } = context['@context'];
+
+/**
+ * Handler that creates an activity in the user's data pod
+ * Requires:
+ * - the `root.user` handler
+ * - the `root[...]` resolver
+ */
+export default class CreateActivityHandler {
+  constructor({ type = `${as}#Like`, path = '/public/activities' } = {}) {
+    this._type = type;
+    this._path = path;
+  }
+
+  execute(path, proxy) {
+    const self = this;
+    const root = proxy.root;
+    const user = root.user;
+
+    // Return an iterator over the new activity URLs
+    return () => iterablePromise((async function* () {
+      // Create an activity for each object on the path
+      const activities = [];
+      const inserts = [];
+      const type = self._type;
+      const actor = await user;
+      const time = new Date().toISOString();
+      for await (const object of proxy) {
+        if (typeof object === 'string' || object.termType === 'NamedNode') {
+          const id = `#${uuid()}`;
+          const props = { id, type, actor, object, time };
+          activities.push(id);
+          inserts.push(self._createActivity(props));
+        }
+      }
+
+      // Send the activity as a patch
+      const location = new URL(self._path, await user.pim_storage);
+      await self._sendPatch(location, { insert: inserts.join('') });
+
+      // Return the URLs of the new activities
+      for (const id of activities)
+        yield root[new URL(id, location)];
+    })());
+  }
+
+  // Creates a Turtle snippet representing the activity
+  _createActivity({ id, type, actor, object, time }) {
+    return activityTemplate
+      .replace(/_:activity/, `<${id}>`)
+      .replace(/_:type/, `<${type}>`)
+      .replace(/_:actor/g, `<${actor}>`)
+      .replace(/_:object/g, `<${object}>`)
+      .replace(/_:published/g, `"${time}"^^<${xsd}dateTime>`);
+  }
+
+  // Sends a PATCH request to create the activity
+  _sendPatch(resource, { insert }) {
+    const patch = `INSERT {\n${insert}\n}`;
+    return auth.fetch(resource, {
+      method: 'PATCH',
+      headers: {
+        'Content-Type': 'application/sparql-update',
+      },
+      body: patch,
+    });
+  }
+}

src/CreateActivityHandler.js

@@ -0,0 +1,4 @@
+_:activity a _:type;
+    <https://www.w3.org/ns/activitystreams#actor> _:actor;
+    <https://www.w3.org/ns/activitystreams#object> _:object;
+    <https://www.w3.org/ns/activitystreams#published> _:published.

src/activity.ttl

@@ -2,12 +2,28 @@ import { PathFactory, StringToLDflexHandler } from 'ldflex';
 import context from './context.json';
 import UserPathHandler from './UserPathHandler';
 import SubjectPathResolver from './SubjectPathResolver';
+import CreateActivityHandler from './CreateActivityHandler';
+
+const { as } = context['@context'];
+
+let rootPath;
 
 // Creates data paths that start from a given subject
-const subjectPathFactory = new PathFactory({ context });
+const subjectPathFactory = new PathFactory({
+  context,
+  handlers: {
+    ...PathFactory.defaultHandlers,
+    // Activities on paths
+    like: new CreateActivityHandler({ type: `${as}Like` }),
+    dislike: new CreateActivityHandler({ type: `${as}Dislike` }),
+    follow: new CreateActivityHandler({ type: `${as}Follow` }),
+    // The `root` property restarts the path from the root
+    root: () => rootPath,
+  },
+});
 
 // Export the root path that resolves the first property access
-export default new PathFactory({
+export default rootPath = new PathFactory({
   // Handlers of specific named properties
   handlers: {
     // Don't get mistaken for an ES6 module by loaders

src/index.js

@@ -1,6 +1,7 @@
 {
   extends: plugin:jest/recommended,
   rules: {
+    camelcase: off,
     global-require: off,
     no-use-before-define: off,
   },

test/.eslintrc

@@ -0,0 +1,48 @@
+import CreateActivityHandler from '../src/CreateActivityHandler';
+import auth from 'solid-auth-client';
+
+describe('a CreateActivityHandler instance', () => {
+  let handler;
+  beforeEach(() => (handler = new CreateActivityHandler()));
+
+  describe('creating a like', () => {
+    beforeEach(async () => {
+      const like = handler.execute(null, createProxy());
+      expect(like).toBeInstanceOf(Function);
+      await like();
+    });
+
+    it('issues a PATCH request', () => {
+      expect(auth.fetch).toHaveBeenCalledTimes(1);
+      const args = auth.fetch.mock.calls[0];
+      expect(args[1]).toHaveProperty('method', 'PATCH');
+    });
+
+    it('sets the Content-Type to application/sparql-update', () => {
+      expect(auth.fetch).toHaveBeenCalledTimes(1);
+      const args = auth.fetch.mock.calls[0];
+      expect(args[1]).toHaveProperty('headers');
+      expect(args[1].headers).toHaveProperty('Content-Type', 'application/sparql-update');
+    });
+
+    it('sends a patch document', () => {
+      expect(auth.fetch).toHaveBeenCalledTimes(1);
+      const args = auth.fetch.mock.calls[0];
+      expect(args[1]).toHaveProperty('body');
+      expect(args[1].body).toMatch(/INSERT/);
+      expect(args[1].body).toMatch(/Like/);
+    });
+  });
+});
+
+function createProxy() {
+  const user = { pim_storage: 'http://user.example/' };
+  const root = { user };
+  const proxy = (async function* proxy() {
+    yield 'http://example.org/#user1';
+    yield { termType: 'NamedNode' };
+    yield 0;
+  }());
+  proxy.root = root;
+  return proxy;
+}

test/CreateActivityHandler-test.js

@@ -1,6 +1,6 @@
 const ComunicaEngine = jest.genMockFromModule('ldflex-comunica').default;
 
-const noResults = { next: async () => ({ done: true }) };
-ComunicaEngine.prototype.execute.mockReturnValue(noResults);
+async function* noResults() { /* empty */ }
+ComunicaEngine.prototype.execute.mockReturnValue(noResults());
 
 export default ComunicaEngine;

test/__mocks__/ldflex-comunica.js

@@ -1,3 +1,4 @@
 export default {
   currentSession: jest.fn(),
+  fetch: jest.fn(),
 };

test/__mocks__/solid-auth-client.js

@@ -56,6 +56,12 @@ describe('The @solid/ldflex module', () => {
       expect(data.resolve()).toBe(data);
     });
   });
+
+  describe('the root path', () => {
+    it('resolves to the root', () => {
+      expect(data.user.root.root.user.root).toBe(data);
+    });
+  });
 });
 
 const urlQuery = `SELECT ?firstName WHERE {