App owned: account linking

CHANGELOG.md

@@ -1,6 +1,10 @@
 # Changelog
 
 
+### v0.32.0
+
+- Adds app owned account linking
+
 ### v0.31.1
 
 Move `madge` and `typedoc-plugin-missing-exports` from `dependencies` into `devDependencies`.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "webnative",
-  "version": "0.31.1",
+  "version": "0.32.0",
   "description": "Fission Webnative SDK",
   "keywords": [
     "WebCrypto",

src/auth/channel.ts

@@ -0,0 +1,73 @@
+import * as did from "../did/index.js"
+import { setup } from "../setup/internal.js"
+import { LinkingError } from "./linking.js"
+
+import type { Maybe } from "../common/index.js"
+
+export type Channel = {
+  send: (data: ChannelData) => void
+  close: () => void
+}
+
+export type ChannelOptions = {
+  username: string
+  handleMessage: (event: MessageEvent) => void
+}
+
+type ChannelData = string | ArrayBufferLike | Blob | ArrayBufferView
+
+export const createChannel = async (options: ChannelOptions): Promise<Channel> => {
+  const { username, handleMessage } = options
+
+  const rootDid = await await did.root(username).catch(_ => null)
+  if (!rootDid) {
+    throw new LinkingError(`Failed to lookup DID for ${username}`)
+  }
+
+  const apiEndpoint = setup.getApiEndpoint()
+  const endpoint = apiEndpoint.replace(/^https?:\/\//, "wss://")
+  const topic = `deviceLink#${rootDid}`
+  console.log("Opening channel", topic)
+
+  const socket: Maybe<WebSocket> = new WebSocket(`${endpoint}/user/link/${rootDid}`)
+  await waitForOpenConnection(socket)
+  socket.onmessage = handleMessage
+
+  const send = publishOnWssChannel(socket)
+  const close = closeWssChannel(socket)
+
+  return {
+    send,
+    close
+  }
+}
+
+const waitForOpenConnection = async (socket: WebSocket): Promise<void> => {
+  return new Promise((resolve, reject) => {
+    socket.onopen = () => {
+      resolve()
+    }
+    socket.onerror = () => {
+      reject("Websocket channel could not be opened")
+    }
+  })
+}
+
+export const closeWssChannel = (socket: Maybe<WebSocket>): () => void => {
+  return function () {
+    if (socket) {
+      socket.close(1000)
+    }
+    socket = null
+  }
+}
+
+export const publishOnWssChannel = (socket: WebSocket): (data: ChannelData) => void => {
+  return function (data: ChannelData) {
+    const binary = typeof data === "string"
+      ? new TextEncoder().encode(data).buffer
+      : data
+
+    socket?.send(binary)
+  }
+}

src/auth/implementation/types.ts

@@ -1,10 +1,15 @@
 import { InitOptions } from "../../init/types.js"
 import { State } from "../state.js"
 
+import type { Channel, ChannelOptions } from "../../auth/channel"
 
 export type Implementation = {
   init: (options: InitOptions) => Promise<State | null>
   register: (options: { email: string; username: string }) => Promise<{ success: boolean }>
   isUsernameValid: (username: string) => Promise<boolean>
   isUsernameAvailable: (username: string) => Promise<boolean>
+  createChannel: (options: ChannelOptions) => Promise<Channel>
+  checkCapability: (username: string) => Promise<boolean>
+  delegateAccount: (username: string, audience: string) => Promise<Record<string, unknown>>
+  linkDevice: (data: Record<string, unknown>) => Promise<void>
 }

src/auth/index.ts

@@ -0,0 +1,7 @@
+import { impl } from "./implementation.js"
+
+const {  isUsernameAvailable, isUsernameValid, register } = impl
+
+export { isUsernameAvailable, isUsernameValid, register }
+export { AccountLinkingRequestor, createConsumer as createRequestor } from "./linking/consumer.js"
+export { AccountLinkingProvider, createProducer as createProvider } from "./linking/producer.js"

src/auth/internal.ts

@@ -3,11 +3,13 @@ import { InitOptions } from "../init/types.js"
 import { State } from "./state.js"
 
 
+import type { Channel, ChannelOptions } from "./channel"
+
 export const init = (options: InitOptions): Promise<State | null> => {
   return authLobby.init(options)
 }
 
-export const register = (options: { username: string; email: string }): Promise<{success: boolean}> => {
+export const register = (options: { username: string; email: string }): Promise<{ success: boolean }> => {
   return authLobby.register(options)
 }
 
@@ -18,3 +20,20 @@ export const isUsernameValid = (username: string): Promise<boolean> => {
 export const isUsernameAvailable = (username: string): Promise<boolean> => {
   return authLobby.isUsernameAvailable(username)
 }
+
+
+export const createChannel = (options: ChannelOptions): Promise<Channel> => {
+  return authLobby.createChannel(options)
+}
+
+export const checkCapability = async (username: string): Promise<boolean> => {
+  return authLobby.checkCapability(username)
+}
+
+export const delegateAccount = (username: string, audience: string): Promise<Record<string, unknown>> => {
+  return authLobby.delegateAccount(username, audience)
+}
+
+export const linkDevice = (data: Record<string, unknown>): Promise<void> => {
+  return authLobby.linkDevice(data)
+}

src/auth/linking.ts

@@ -0,0 +1,60 @@
+import type { Result } from "../common/index.js"
+
+import * as debug from "../common/debug.js"
+
+
+export class LinkingError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = "LinkingError"
+  }
+}
+
+export class LinkingWarning extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = "LinkingWarning"
+  }
+}
+
+export const handleLinkingError = (error: LinkingError | LinkingWarning): void => {
+  switch (error.name) {
+    case "LinkingWarning":
+      debug.warn(error.message)
+      break
+
+    case "LinkingError":
+      throw error
+
+    default:
+      throw error
+  }
+}
+
+export const tryParseMessage = <T>(
+  data: string,
+  typeGuard: (message: unknown) => message is T,
+  context: { participant: string; callSite: string }
+): Result<T, LinkingWarning> => {
+  try {
+    const message = JSON.parse(data)
+
+    if (typeGuard(message)) {
+      return {
+        ok: true,
+        value: message
+      }
+    } else {
+      return {
+        ok: false,
+        error: new LinkingWarning(`${context.participant} received an unexpected message in ${context.callSite}: ${data}. Ignoring message.`)
+      }
+    }
+
+  } catch {
+    return {
+      ok: false,
+      error: new LinkingWarning(`${context.participant} received a message in ${context.callSite} that it could not parse: ${data}. Ignoring message.`)
+    }
+  }
+}