@hocuspocus/provider 1.0.0-alpha.4 → 1.0.0-alpha.40

package/src/IncomingMessage.ts

@@ -1,25 +1,49 @@
-import * as decoding from 'lib0/decoding'
-import * as encoding from 'lib0/encoding'
+import {
+  createDecoder,
+  readVarUint,
+  readVarUint8Array,
+  Decoder,
+} from 'lib0/decoding'
+import {
+  Encoder,
+  createEncoder,
+  writeVarUint,
+  writeVarUint8Array,
+  length,
+} from 'lib0/encoding'
 import { MessageType } from './types'
 
 export class IncomingMessage {
 
   data: any
 
-  encoder: encoding.Encoder
+  encoder: Encoder
 
-  decoder: decoding.Decoder
-
-  type: MessageType
+  decoder: Decoder
 
   constructor(data: any) {
     this.data = data
-    this.encoder = encoding.createEncoder()
-    this.decoder = decoding.createDecoder(new Uint8Array(this.data))
-    this.type = decoding.readVarUint(this.decoder)
+    this.encoder = createEncoder()
+    this.decoder = createDecoder(new Uint8Array(this.data))
+  }
+
+  readVarUint(): MessageType {
+    return readVarUint(this.decoder)
+  }
+
+  readVarUint8Array() {
+    return readVarUint8Array(this.decoder)
+  }
+
+  writeVarUint(type: MessageType) {
+    return writeVarUint(this.encoder, type)
+  }
+
+  writeVarUint8Array(data: Uint8Array) {
+    return writeVarUint8Array(this.encoder, data)
   }
 
-  get name() {
-    return MessageType[this.type]
+  length() {
+    return length(this.encoder)
   }
 }

package/src/MessageReceiver.ts

@@ -1,22 +1,32 @@
-import * as decoding from 'lib0/decoding'
-import * as encoding from 'lib0/encoding'
 import * as awarenessProtocol from 'y-protocols/awareness'
-import * as syncProtocol from 'y-protocols/sync'
-import * as authProtocol from 'y-protocols/auth'
+import { readSyncMessage, messageYjsSyncStep2, messageYjsUpdate } from 'y-protocols/sync'
+import { readAuthMessage } from '@hocuspocus/common'
 import { MessageType } from './types'
 import { HocuspocusProvider } from './HocuspocusProvider'
 import { IncomingMessage } from './IncomingMessage'
+import { OutgoingMessage } from './OutgoingMessage'
 
 export class MessageReceiver {
 
   message: IncomingMessage
 
+  broadcasted = false
+
   constructor(message: IncomingMessage) {
     this.message = message
   }
 
+  public setBroadcasted(value: boolean) {
+    this.broadcasted = value
+
+    return this
+  }
+
   public apply(provider: HocuspocusProvider, emitSynced = true) {
-    switch (this.message.type) {
+    const { message } = this
+    const type = message.readVarUint()
+
+    switch (type) {
       case MessageType.Sync:
         this.applySyncMessage(provider, emitSynced)
         break
@@ -34,51 +44,73 @@ export class MessageReceiver {
         break
 
       default:
-        throw new Error(`Can’t apply unknown type of message: ${this.message.type}`)
+        throw new Error(`Can’t apply message of unknown type: ${type}`)
     }
 
-    return this.message.encoder
+    // Reply
+    if (message.length() > 1) {
+      if (this.broadcasted) {
+        // TODO: Some weird TypeScript error
+        // @ts-ignore
+        provider.broadcast(OutgoingMessage, { encoder: message.encoder })
+      } else {
+        // TODO: Some weird TypeScript error
+        // @ts-ignore
+        provider.send(OutgoingMessage, { encoder: message.encoder })
+      }
+    }
   }
 
   private applySyncMessage(provider: HocuspocusProvider, emitSynced: boolean) {
-    encoding.writeVarUint(this.message.encoder, MessageType.Sync)
+    const { message } = this
+
+    message.writeVarUint(MessageType.Sync)
 
-    const syncMessageType = syncProtocol.readSyncMessage(
-      this.message.decoder,
-      this.message.encoder,
+    // Apply update
+    const syncMessageType = readSyncMessage(
+      message.decoder,
+      message.encoder,
       provider.document,
       provider,
     )
 
-    if (emitSynced && syncMessageType === syncProtocol.messageYjsSyncStep2) {
+    // Synced once we receive Step2
+    if (emitSynced && (syncMessageType === messageYjsSyncStep2)) {
       provider.synced = true
     }
+
+    if (syncMessageType === messageYjsUpdate || syncMessageType === messageYjsSyncStep2) {
+      if (provider.unsyncedChanges > 0) {
+        provider.unsyncedChanges -= 1
+      }
+    }
   }
 
   private applyAwarenessMessage(provider: HocuspocusProvider) {
+    const { message } = this
+
     awarenessProtocol.applyAwarenessUpdate(
       provider.awareness,
-      decoding.readVarUint8Array(this.message.decoder),
+      message.readVarUint8Array(),
       provider,
     )
   }
 
-  // TODO: This isn’t really used. Needs to be implemented in the server, or removed here.
   private applyAuthMessage(provider: HocuspocusProvider) {
-    authProtocol.readAuthMessage(
-      this.message.decoder,
-      provider.document,
-      // TODO: Add a configureable hook
-      (provider, reason) => {
-        console.warn(`Permission denied to access ${provider.url}.\n${reason}`)
-      },
+    const { message } = this
+
+    readAuthMessage(
+      message.decoder,
+      provider.permissionDeniedHandler.bind(provider),
+      provider.authenticatedHandler.bind(provider),
     )
   }
 
   private applyQueryAwarenessMessage(provider: HocuspocusProvider) {
-    encoding.writeVarUint(this.message.encoder, MessageType.Awareness)
-    encoding.writeVarUint8Array(
-      this.message.encoder,
+    const { message } = this
+
+    message.writeVarUint(MessageType.Awareness)
+    message.writeVarUint8Array(
       awarenessProtocol.encodeAwarenessUpdate(
         provider.awareness,
         Array.from(provider.awareness.getStates().keys()),

package/src/MessageSender.ts

@@ -1,32 +1,20 @@
-import * as encoding from 'lib0/encoding'
+import { Encoder, toUint8Array } from 'lib0/encoding'
 import * as bc from 'lib0/broadcastchannel'
-import { OutgoingMessage } from './OutgoingMessage'
-import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage'
-import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage'
-import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage'
-import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage'
-import { UpdateMessage } from './OutgoingMessages/UpdateMessage'
-import { Constructable } from './types'
+import { ConstructableOutgoingMessage } from './types'
 
 export class MessageSender {
 
-  encoder: encoding.Encoder
+  encoder: Encoder
 
   message: any
 
-  constructor(Message:
-    Constructable<AwarenessMessage> |
-    Constructable<QueryAwarenessMessage> |
-    Constructable<SyncStepOneMessage> |
-    Constructable<SyncStepTwoMessage> |
-    Constructable<UpdateMessage>,
-  args: any = {}) {
+  constructor(Message: ConstructableOutgoingMessage, args: any = {}) {
     this.message = new Message()
     this.encoder = this.message.get(args)
   }
 
   create() {
-    return encoding.toUint8Array(this.encoder)
+    return toUint8Array(this.encoder)
   }
 
   send(webSocket: any) {

package/src/OutgoingMessage.ts

@@ -1,20 +1,20 @@
-import * as encoding from 'lib0/encoding'
-import { MessageType, OutgoingMessageInterface } from './types'
+import { Encoder, createEncoder, toUint8Array } from 'lib0/encoding'
+import { MessageType, OutgoingMessageArguments, OutgoingMessageInterface } from './types'
 
 export class OutgoingMessage implements OutgoingMessageInterface {
-  encoder: encoding.Encoder
+  encoder: Encoder
 
   type?: MessageType
 
   constructor() {
-    this.encoder = encoding.createEncoder()
+    this.encoder = createEncoder()
   }
 
-  get name() {
-    if (typeof this.type === 'number') {
-      return MessageType[this.type]
-    }
+  get(args: Partial<OutgoingMessageArguments>) {
+    return args.encoder
+  }
 
-    throw new Error('Type for outgoing message not set.')
+  toUint8Array() {
+    return toUint8Array(this.encoder)
   }
 }

package/src/OutgoingMessages/AuthenticationMessage.ts

@@ -0,0 +1,21 @@
+import { writeVarUint } from 'lib0/encoding'
+import { writeAuthentication } from '@hocuspocus/common'
+import { MessageType, OutgoingMessageArguments } from '../types'
+import { OutgoingMessage } from '../OutgoingMessage'
+
+export class AuthenticationMessage extends OutgoingMessage {
+  type = MessageType.Auth
+
+  description = 'Authentication'
+
+  get(args: Partial<OutgoingMessageArguments>) {
+    if (typeof args.token === 'undefined') {
+      throw new Error('The authentication message requires `token` as an argument.')
+    }
+
+    writeVarUint(this.encoder, this.type)
+    writeAuthentication(this.encoder, args.token)
+
+    return this.encoder
+  }
+}

package/src/OutgoingMessages/AwarenessMessage.ts

@@ -1,5 +1,5 @@
 import * as encoding from 'lib0/encoding'
-import { Awareness, encodeAwarenessUpdate } from 'y-protocols/awareness'
+import { encodeAwarenessUpdate } from 'y-protocols/awareness'
 import { MessageType, OutgoingMessageArguments } from '../types'
 import { OutgoingMessage } from '../OutgoingMessage'
 

package/src/OutgoingMessages/SyncStepOneMessage.ts

@@ -1,4 +1,3 @@
-import * as Y from 'yjs'
 import * as encoding from 'lib0/encoding'
 import * as syncProtocol from 'y-protocols/sync'
 import { MessageType, OutgoingMessageArguments } from '../types'

package/src/OutgoingMessages/UpdateMessage.ts

@@ -1,5 +1,5 @@
-import * as encoding from 'lib0/encoding'
-import * as syncProtocol from 'y-protocols/sync'
+import { writeVarUint } from 'lib0/encoding'
+import { writeUpdate } from 'y-protocols/sync'
 import { MessageType, OutgoingMessageArguments } from '../types'
 import { OutgoingMessage } from '../OutgoingMessage'
 
@@ -9,8 +9,8 @@ export class UpdateMessage extends OutgoingMessage {
   description = 'A document update'
 
   get(args: Partial<OutgoingMessageArguments>) {
-    encoding.writeVarUint(this.encoder, this.type)
-    syncProtocol.writeUpdate(this.encoder, args.update)
+    writeVarUint(this.encoder, this.type)
+    writeUpdate(this.encoder, args.update)
 
     return this.encoder
   }

package/src/index.ts

@@ -1,3 +1,3 @@
 export * from './HocuspocusProvider'
+export * from './HocuspocusCloudProvider'
 export * from './types'
-export * from './utils'

package/src/types.ts

@@ -1,6 +1,15 @@
 import { Awareness } from 'y-protocols/awareness'
 import * as Y from 'yjs'
-import * as encoding from 'lib0/encoding'
+import { Encoder } from 'lib0/encoding'
+import type { Event, CloseEvent, MessageEvent } from 'ws'
+import { AuthenticationMessage } from './OutgoingMessages/AuthenticationMessage'
+import { AwarenessMessage } from './OutgoingMessages/AwarenessMessage'
+import { QueryAwarenessMessage } from './OutgoingMessages/QueryAwarenessMessage'
+import { SyncStepOneMessage } from './OutgoingMessages/SyncStepOneMessage'
+import { SyncStepTwoMessage } from './OutgoingMessages/SyncStepTwoMessage'
+import { UpdateMessage } from './OutgoingMessages/UpdateMessage'
+import { IncomingMessage } from './IncomingMessage'
+import { OutgoingMessage } from './OutgoingMessage'
 
 export enum MessageType {
   Sync = 0,
@@ -9,20 +18,78 @@ export enum MessageType {
   QueryAwareness = 3,
 }
 
-export interface OutgoingMessageInterface {
-  encoder: encoding.Encoder
+export enum WebSocketStatus {
+  Connecting = 'connecting',
+  Connected = 'connected',
+  Disconnected = 'disconnected',
+}
 
+export interface OutgoingMessageInterface {
+  encoder: Encoder
   type?: MessageType
 }
 
 export interface OutgoingMessageArguments {
+  token: string,
   document: Y.Doc,
   awareness: Awareness,
   clients: number[],
   states: Map<number, { [key: string]: any; }>,
   update: any,
+  encoder: Encoder,
 }
 
 export interface Constructable<T> {
   new(...args: any) : T
 }
+
+export type ConstructableOutgoingMessage =
+  Constructable<AuthenticationMessage> |
+  Constructable<AwarenessMessage> |
+  Constructable<QueryAwarenessMessage> |
+  Constructable<SyncStepOneMessage> |
+  Constructable<SyncStepTwoMessage> |
+  Constructable<UpdateMessage>
+
+export type onAuthenticationFailedParameters = {
+  reason: string,
+}
+
+export type onOpenParameters = {
+  event: Event,
+}
+
+export type onMessageParameters = {
+  event: MessageEvent,
+  message: IncomingMessage,
+}
+
+export type onOutgoingMessageParameters = {
+  message: OutgoingMessage,
+}
+
+export type onStatusParameters = {
+  status: WebSocketStatus,
+}
+
+export type onSyncedParameters = {
+  state: boolean,
+}
+
+export type onDisconnectParameters = {
+  event: CloseEvent,
+}
+
+export type onCloseParameters = {
+  event: CloseEvent,
+}
+
+export type onAwarenessUpdateParameters = {
+  states: StatesArray
+}
+
+export type onAwarenessChangeParameters = {
+  states: StatesArray
+}
+
+export type StatesArray = { clientId: number, [key: string | number]: any }[]

package/CHANGELOG.md

@@ -1,24 +0,0 @@
-# Change Log
-
-All notable changes to this project will be documented in this file.
-See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
-
-# [1.0.0-alpha.4](https://github.com/ueberdosis/hocuspocus/compare/@hocuspocus/provider@1.0.0-alpha.3...@hocuspocus/provider@1.0.0-alpha.4) (2021-06-09)
-
-**Note:** Version bump only for package @hocuspocus/provider
-
-
-
-
-
-# [1.0.0-alpha.3](https://github.com/ueberdosis/hocuspocus/compare/@hocuspocus/provider@1.0.0-alpha.2...@hocuspocus/provider@1.0.0-alpha.3) (2021-06-09)
-
-**Note:** Version bump only for package @hocuspocus/provider
-
-
-
-
-
-# 1.0.0-alpha.2 (2021-06-08)
-
-**Note:** Version bump only for package @hocuspocus/provider