[subscription] first draft of SubscriptionClient

Author: elf-pavlik

package.json

@@ -9,6 +9,7 @@
     "packages/*"
   ],
   "devDependencies": {
+    "@types/jest": "^29.5.0",
     "@types/node": "^18.15.11",
     "@typescript-eslint/eslint-plugin": "^5.57.1",
     "@typescript-eslint/parser": "^5.57.1",
@@ -17,6 +18,7 @@
     "eslint-plugin-prettier": "^4.2.1",
     "jest": "^29.5.0",
     "lerna": "^6.6.1",
-    "typescript": "^5.0.3"
+    "typescript": "^5.0.3",
+    "ts-jest": "^29.1.0"
   }
 }

packages/subscription/jest.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  coveragePathIgnorePatterns: ["/test/"],
+  testRegex: ["/test/.*.test.*.ts$"],
+};

packages/subscription/package.json

@@ -24,9 +24,19 @@
     "url": "git+https://github.com/o-development/solid-notification-client.git"
   },
   "scripts": {
-    "tsc": "tsc"
+    "tsc": "tsc",
+    "test": "jest --coverage"
   },
   "bugs": {
     "url": "https://github.com/o-development/solid-notification-client/issues"
+  },
+  "devDependencies": {
+    "@solid-notifications/types": "^0.1.0",
+    "solid-test-utils": "^0.0.0"
+  },
+  "dependencies": {
+    "@janeirodigital/interop-utils": "^1.0.0-rc.21",
+    "@solid-notifications/discovery": "^0.1.0",
+    "n3": "^1.17.0"
   }
 }

packages/subscription/src/client.ts

@@ -0,0 +1,72 @@
+import { DataFactory, Store } from 'n3'
+import { NOTIFY, RDF, getOneMatchingQuad, parseTurtle, serializeTurtle } from '@janeirodigital/interop-utils'
+import { DiscoveryClient } from '@solid-notifications/discovery'
+
+import type { DatasetCore } from '@rdfjs/types'
+import type { ChannelType, NotificationChannel } from '@solid-notifications/types'
+
+function buildChannel(topic: string, channelType: ChannelType, sendTo: string): DatasetCore {
+  const channel = new Store() as DatasetCore
+  const subject = DataFactory.blankNode()
+  channel.add(DataFactory.quad(subject, RDF.type, DataFactory.namedNode(channelType)))
+  channel.add(DataFactory.quad(subject, NOTIFY.topic, DataFactory.namedNode(topic)))
+  if (sendTo) {
+    channel.add(DataFactory.quad(subject, NOTIFY.sendTo, DataFactory.namedNode(sendTo)))
+  }
+  return channel
+}
+
+function formatChannel(dataset: DatasetCore): NotificationChannel {
+  const subject = getOneMatchingQuad(dataset, null, RDF.type).subject
+  const channel = {
+    id: subject.value,
+    type: getOneMatchingQuad(dataset, subject, RDF.type).object.value as ChannelType, // TODO: improve typing
+    topic: getOneMatchingQuad(dataset, subject, NOTIFY.topic).object.value,
+  } as NotificationChannel
+  const receiveFrom = getOneMatchingQuad(dataset, subject, NOTIFY.receiveFrom)?.object.value
+  if (receiveFrom) channel.receiveFrom = receiveFrom
+  const sendTo = getOneMatchingQuad(dataset, subject, NOTIFY.sendTo)?.object.value
+  if (sendTo) channel.sendTo = sendTo
+
+  return channel
+}
+
+
+export class SubscriptionClient {
+  private rdf: {
+    contentType: 'text/turtle' | 'application/ld+json',
+    parse: typeof parseTurtle
+    serialize: typeof serializeTurtle
+  }
+
+  discovery = new DiscoveryClient(this.authnFetch)
+
+  constructor(private authnFetch: typeof fetch) {
+    // TODO pass Turtle or JSON-LD parser and set accordignly
+    this.rdf = {
+      contentType: 'text/turtle',
+      parse: parseTurtle,
+      serialize: serializeTurtle
+    }
+  }
+
+  async subscribe(topic: string, channelType: ChannelType, sendTo?: string): Promise<NotificationChannel> {
+    // TODO: validate presence of sendTo based on known channel type
+    const service = await this.discovery.findService(topic, channelType)
+    const requestedChannel = buildChannel(topic, channelType, sendTo)
+    const response = await this.authnFetch(service.id, {
+      method: 'POST',
+      body: await this.rdf.serialize(requestedChannel),
+      headers: {
+        'Accept': this.rdf.contentType,
+        'Content-Type': this.rdf.contentType
+      }
+    })
+    if(!response.headers.get('Content-Type').startsWith(this.rdf.contentType)) {
+      throw new Error('unexpected Content Type')
+    }
+    const dataset = await this.rdf.parse(await response.text(), response.url)
+    return formatChannel(dataset)
+  }
+
+}

packages/subscription/src/index.ts

@@ -1 +1 @@
-console.log("Hello World");
+export * from "./client";

packages/subscription/test/client.test.ts

@@ -0,0 +1,33 @@
+import SolidTestUtils from "solid-test-utils";
+import { SubscriptionClient } from "../src/client";
+import { NOTIFY } from "@janeirodigital/interop-utils";
+
+describe("subscription", () => {
+  const stu = new SolidTestUtils();
+  beforeAll(async () => stu.beforeAll());
+  afterAll(async () => stu.afterAll());
+
+  const cardUri = "http://localhost:3001/example/profile/card"
+
+  test("subscribe for Webhook", async () => {
+    const client = new SubscriptionClient(stu.authFetch)
+    const sendTo = 'https://webhook.example/086b0e2a-25ea-4b94-a3c6-d2ddfcd1e022'
+    const channel = await client.subscribe(cardUri, NOTIFY.WebhookChannel2023.value, sendTo)
+    expect(channel).toEqual(expect.objectContaining({
+      type: NOTIFY.WebhookChannel2023.value,
+      topic: cardUri,
+      sendTo
+    }))
+  });
+
+  test("subscribe for Web Socket", async () => {
+    const client = new SubscriptionClient(stu.authFetch)
+    const channel = await client.subscribe(cardUri, NOTIFY.WebSocketChannel2023.value)
+    expect(channel).toEqual(expect.objectContaining({
+      type: NOTIFY.WebSocketChannel2023.value,
+      topic: cardUri,
+      receiveFrom: expect.stringContaining('ws://localhost:3001/.notifications/WebSocketChannel2023/')
+    }))
+  });
+
+});