@hocuspocus/provider 1.0.0-alpha.35 → 1.0.0-alpha.38

package/dist/packages/extension-database/src/Database.d.ts

@@ -1,12 +1,10 @@
-import { Extension, onChangePayload, onLoadDocumentPayload, storePayload } from '@hocuspocus/server';
+import { Extension, onChangePayload, onLoadDocumentPayload, storePayload, fetchPayload } from '@hocuspocus/server';
 export interface DatabaseConfiguration {
     /**
      * Pass a Promise to retrieve updates from your database. The Promise should resolve to
      * an array of items with Y.js-compatible binary data.
      */
-    fetch: ({ documentName }: {
-        documentName: string;
-    }) => Promise<Uint8Array | null>;
+    fetch: (data: fetchPayload) => Promise<Uint8Array | null>;
     /**
      * Pass a function to store updates in your database.
      */
@@ -24,7 +22,7 @@ export declare class Database implements Extension {
     /**
      * Get stored data from the database.
      */
-    onLoadDocument({ document, documentName }: onLoadDocumentPayload): Promise<any>;
+    onLoadDocument(data: onLoadDocumentPayload): Promise<any>;
     /**
      * Store new updates in the database.
      */

package/dist/packages/extension-monitor/src/Collector.d.ts

@@ -50,11 +50,12 @@ export declare class Collector {
     documents(): {};
     info(): Promise<{
         configuration: Partial<Configuration>;
-        ipAddress: string;
+        ipAddress: string | null;
         nodeVersion: string;
         platform: NodeJS.Platform;
         started: string;
         version: string;
     }>;
+    private getIpAddress;
     private static readableYDoc;
 }

package/dist/packages/extension-redis/src/Redis.d.ts

@@ -1,16 +1,98 @@
-import { RedisPersistence } from 'y-redis';
-import { Extension, onConnectPayload, onLoadDocumentPayload, onDisconnectPayload } from '@hocuspocus/server';
+import RedisClient from 'ioredis';
+import Redlock from 'redlock';
+import { Document, Extension, afterLoadDocumentPayload, afterStoreDocumentPayload, onDisconnectPayload, onStoreDocumentPayload, onAwarenessUpdatePayload, onChangePayload, Debugger, onConfigurePayload, onListenPayload } from '@hocuspocus/server';
 export interface Configuration {
+    /**
+     * Redis port
+     */
+    port: number;
+    /**
+     * Redis host
+     */
+    host: string;
+    /**
+     * Options passed directly to Redis constructor
+     *
+     * https://github.com/luin/ioredis/blob/master/API.md#new-redisport-host-options
+     */
+    options?: RedisClient.RedisOptions;
+    /**
+     * An unique instance name, required to filter messages in Redis.
+     * If none is provided an unique id is generated.
+     */
+    identifier: string;
+    /**
+     * Namespace for Redis keys, if none is provided 'hocuspocus' is used
+     */
+    prefix: string;
+    /**
+     * The maximum time for the Redis lock in ms (in case it can’t be released).
+     */
+    lockTimeout: number;
 }
 export declare class Redis implements Extension {
+    /**
+     * Make sure to give that extension a higher priority, so
+     * the `onStoreDocument` hook is able to intercept the chain,
+     * before documents are stored to the database.
+     */
+    priority: number;
     configuration: Configuration;
-    cluster: boolean;
-    persistence: RedisPersistence | undefined;
+    pub: RedisClient.Redis;
+    sub: RedisClient.Redis;
+    documents: Map<string, Document>;
+    redlock: Redlock;
+    locks: Map<string, Redlock.Lock>;
+    logger: Debugger;
+    constructor(configuration: Partial<Configuration>);
+    onConfigure({ instance }: onConfigurePayload): Promise<void>;
+    onListen({ configuration }: onListenPayload): Promise<void>;
+    private getKey;
+    private pubKey;
+    private subKey;
+    private lockKey;
+    /**
+     * Once a document is laoded, subscribe to the channel in Redis.
+     */
+    afterLoadDocument({ documentName, document }: afterLoadDocumentPayload): Promise<unknown>;
+    /**
+     * Publish the first sync step through Redis.
+     */
+    private publishFirstSyncStep;
+    /**
+     * Let’s ask Redis who is connected already.
+     */
+    private requestAwarenessFromOtherInstances;
+    /**
+     * Before the document is stored, make sure to set a lock in Redis.
+     * That’s meant to avoid conflicts with other instances trying to store the document.
+     */
+    onStoreDocument({ documentName }: onStoreDocumentPayload): Promise<unknown>;
+    /**
+     * Release the Redis lock, so other instances can store documents.
+     */
+    afterStoreDocument({ documentName }: afterStoreDocumentPayload): Promise<void>;
+    /**
+     * Handle awareness update messages received directly by this Hocuspocus instance.
+     */
+    onAwarenessUpdate({ documentName, awareness }: onAwarenessUpdatePayload): Promise<number>;
+    /**
+     * Handle incoming messages published on all subscribed document channels.
+     * Note that this will also include messages from ourselves as it is not possible
+     * in Redis to filter these.
+    */
+    private handleIncomingMessage;
+    /**
+     * if the ydoc changed, we'll need to inform other Hocuspocus servers about it.
+     */
+    onChange(data: onChangePayload): Promise<any>;
+    /**
+     * Make sure to *not* listen for further changes, when there’s
+     * noone connected anymore.
+     */
+    onDisconnect: ({ documentName, clientsCount }: onDisconnectPayload) => Promise<void>;
     /**
-     * Constructor
+     * Kill the Redlock connection immediately.
      */
-    constructor(configuration?: Partial<Configuration>);
-    onLoadDocument(data: onLoadDocumentPayload): Promise<import("yjs").Doc | undefined>;
-    onConnect(data: onConnectPayload): Promise<void>;
-    onDisconnect(data: onDisconnectPayload): Promise<void>;
+    onDestroy(): Promise<void>;
 }

package/dist/packages/extension-redis/src/index.d.ts

@@ -1,2 +1 @@
 export * from './Redis';
-export * from './RedisCluster';

package/dist/packages/provider/src/HocuspocusProvider.d.ts

@@ -110,6 +110,7 @@ export declare class HocuspocusProvider extends EventEmitter {
     shouldConnect: boolean;
     status: WebSocketStatus;
     isSynced: boolean;
+    unsyncedChanges: number;
     isAuthenticated: boolean;
     lastMessageReceived: number;
     mux: mutex.mutex;
@@ -120,6 +121,7 @@ export declare class HocuspocusProvider extends EventEmitter {
     } | null;
     constructor(configuration: HocuspocusProviderConfiguration);
     setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
+    boundConnect: () => Promise<void>;
     connect(): Promise<void>;
     createWebSocketConnection(): Promise<unknown>;
     resolveConnectionAttempt(): void;
@@ -127,8 +129,11 @@ export declare class HocuspocusProvider extends EventEmitter {
     rejectConnectionAttempt(): void;
     get document(): Y.Doc;
     get awareness(): Awareness;
+    get hasUnsyncedChanges(): boolean;
     checkConnection(): void;
     forceSync(): void;
+    boundBeforeUnload: () => void;
+    beforeUnload(): void;
     registerEventListeners(): void;
     documentUpdateHandler(update: Uint8Array, origin: any): void;
     awarenessUpdateHandler({ added, updated, removed }: any, origin: any): void;
@@ -148,6 +153,7 @@ export declare class HocuspocusProvider extends EventEmitter {
     onClose(event: CloseEvent): void;
     destroy(): void;
     get broadcastChannel(): string;
+    boundBroadcastChannelSubscriber: (data: ArrayBuffer) => void;
     broadcastChannelSubscriber(data: ArrayBuffer): void;
     subscribeToBroadcastChannel(): void;
     disconnectBroadcastChannel(): void;

package/dist/packages/server/src/Document.d.ts

@@ -19,7 +19,7 @@ export declare class Document extends Doc {
     /**
      * Constructor.
      */
-    constructor(name: string, logger: Debugger);
+    constructor(name: string, logger: Debugger, yDocOptions: {});
     /**
      * Check if the Document is empty
      */

package/dist/packages/server/src/Hocuspocus.d.ts

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import WebSocket, { AddressInfo, WebSocketServer } from 'ws';
 import { IncomingMessage, Server as HTTPServer } from 'http';
-import { Configuration, Hook } from './types';
+import { Configuration, HookName, HookPayload } from './types';
 import Document from './Document';
 import { Debugger } from './Debugger';
 import { onListenPayload } from '.';
@@ -12,6 +12,10 @@ export declare const defaultConfiguration: {
     debounce: number;
     maxDebounce: number;
     quiet: boolean;
+    yDocOptions: {
+        gc: boolean;
+        gcFilter: () => boolean;
+    };
 };
 /**
  * Hocuspocus Server
@@ -88,7 +92,7 @@ export declare class Hocuspocus {
      * Run the given hook on all configured extensions.
      * Runs the given callback after each hook.
      */
-    hooks(name: Hook, payload: any, callback?: Function | null): Promise<any>;
+    hooks(name: HookName, payload: HookPayload, callback?: Function | null): Promise<any>;
     /**
      * Get parameters by the given request
      */

package/dist/packages/server/src/MessageReceiver.d.ts

@@ -8,6 +8,6 @@ export declare class MessageReceiver {
     logger: Debugger;
     constructor(message: IncomingMessage, logger: Debugger);
     apply(document: Document, connection?: Connection, reply?: (message: Uint8Array) => void): void;
-    readSyncMessage(message: IncomingMessage, document: Document, connection?: Connection, reply?: (message: Uint8Array) => void): 0 | 2 | 1;
+    readSyncMessage(message: IncomingMessage, document: Document, connection?: Connection, reply?: (message: Uint8Array) => void, requestFirstSync?: boolean): 0 | 2 | 1;
     applyQueryAwarenessMessage(awareness: Awareness, reply?: (message: Uint8Array) => void): void;
 }

package/dist/packages/server/src/OutgoingMessage.d.ts

@@ -7,6 +7,7 @@ export declare class OutgoingMessage {
     category?: string;
     constructor();
     createSyncMessage(): OutgoingMessage;
+    createSyncReplyMessage(): OutgoingMessage;
     createAwarenessUpdateMessage(awareness: Awareness, changedClients?: Array<any>): OutgoingMessage;
     writeQueryAwareness(): OutgoingMessage;
     writeAuthenticated(): OutgoingMessage;

package/dist/packages/server/src/index.d.ts

@@ -1,9 +1,8 @@
-export * from './Hocuspocus';
 export * from './Connection';
+export * from './Debugger';
 export * from './Document';
+export * from './Hocuspocus';
 export * from './IncomingMessage';
+export * from './MessageReceiver';
 export * from './OutgoingMessage';
 export * from './types';
-export * from './MessageReceiver';
-export * from './Document';
-export * from './Connection';

package/dist/packages/server/src/types.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
 import { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'http';
 import { URLSearchParams } from 'url';
-import { Socket } from 'net';
 import { Awareness } from 'y-protocols/awareness';
 import Document from './Document';
 import { Hocuspocus } from './Hocuspocus';
@@ -10,7 +9,8 @@ export declare enum MessageType {
     Sync = 0,
     Awareness = 1,
     Auth = 2,
-    QueryAwareness = 3
+    QueryAwareness = 3,
+    SyncReply = 4
 }
 export interface AwarenessUpdate {
     added: Array<any>;
@@ -44,11 +44,12 @@ export interface Extension {
     onDisconnect?(data: onDisconnectPayload): Promise<any>;
     onDestroy?(data: onDestroyPayload): Promise<any>;
 }
-export declare type Hook = 'onConfigure' | 'onListen' | 'onUpgrade' | 'onConnect' | 'connected' | 'onAuthenticate' | 
+export declare type HookName = 'onConfigure' | 'onListen' | 'onUpgrade' | 'onConnect' | 'connected' | 'onAuthenticate' | 
 /**
  * @deprecated onCreateDocument is deprecated, use onLoadDocument instead
  */
 'onCreateDocument' | 'onLoadDocument' | 'afterLoadDocument' | 'onChange' | 'onStoreDocument' | 'afterStoreDocument' | 'onAwarenessUpdate' | 'onRequest' | 'onDisconnect' | 'onDestroy';
+export declare type HookPayload = onConfigurePayload | onListenPayload | onUpgradePayload | onConnectPayload | connectedPayload | onAuthenticatePayload | onLoadDocumentPayload | onChangePayload | onStoreDocumentPayload | afterStoreDocumentPayload | onAwarenessUpdatePayload | onRequestPayload | onDisconnectPayload | onDestroyPayload;
 export interface Configuration extends Extension {
     /**
      * A name for the instance, used for logging.
@@ -79,6 +80,13 @@ export interface Configuration extends Extension {
      * By default, the servers show a start screen. If passed false, the server will start quietly.
      */
     quiet: boolean;
+    /**
+     * options to pass to the ydoc document
+     */
+    yDocOptions: {
+        gc: boolean;
+        gcFilter: () => boolean;
+    };
     /**
      * Function which returns the (customized) document name based on the request
      */
@@ -179,6 +187,16 @@ export declare type StatesArray = {
     clientId: number;
     [key: string | number]: any;
 }[];
+export interface fetchPayload {
+    context: any;
+    document: Document;
+    documentName: string;
+    instance: Hocuspocus;
+    requestHeaders: IncomingHttpHeaders;
+    requestParameters: URLSearchParams;
+    socketId: string;
+    connection: ConnectionConfiguration;
+}
 export interface storePayload extends onStoreDocumentPayload {
     state: Buffer;
 }
@@ -198,19 +216,21 @@ export interface onRequestPayload {
     instance: Hocuspocus;
 }
 export interface onUpgradePayload {
-    head: any;
     request: IncomingMessage;
-    socket: Socket;
+    socket: any;
+    head: any;
     instance: Hocuspocus;
 }
 export interface onListenPayload {
+    instance: Hocuspocus;
+    configuration: Configuration;
     port: number;
 }
 export interface onDestroyPayload {
     instance: Hocuspocus;
 }
 export interface onConfigurePayload {
+    instance: Hocuspocus;
     configuration: Configuration;
     version: string;
-    instance: Hocuspocus;
 }

package/dist/tests/utils/index.d.ts

@@ -2,6 +2,7 @@ export * from './createDirectory';
 export * from './flushRedis';
 export * from './newHocuspocus';
 export * from './newHocuspocusProvider';
+export * from './randomInteger';
 export * from './redisConnectionSettings';
 export * from './removeDirectory';
 export * from './sleep';

package/dist/tests/utils/randomInteger.d.ts

@@ -0,0 +1 @@
+export declare const randomInteger: (min: number, max: number) => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hocuspocus/provider",
-  "version": "1.0.0-alpha.35",
+  "version": "1.0.0-alpha.38",
   "description": "hocuspocus provider",
   "homepage": "https://hocuspocus.dev",
   "keywords": [
@@ -11,7 +11,7 @@
   ],
   "license": "MIT",
   "type": "module",
-  "main": "dist/hocuspocus-provider.esm.js",
+  "main": "dist/hocuspocus-provider.cjs",
   "module": "dist/hocuspocus-provider.esm.js",
   "types": "dist/packages/provider/src/index.d.ts",
   "exports": {
@@ -28,11 +28,11 @@
     "dist"
   ],
   "dependencies": {
-    "@hocuspocus/common": "^1.0.0-alpha.10",
+    "@hocuspocus/common": "^1.0.0-alpha.11",
     "@lifeomic/attempt": "^3.0.2",
     "lib0": "^0.2.46",
     "y-protocols": "^1.0.5",
     "yjs": "^13.5.29"
   },
-  "gitHead": "1fc2a6cff1b5fd626b8dd7c486755111965da20d"
+  "gitHead": "fe784d26fb1b281ab6d0bc7b5fca500be3b62684"
 }

package/src/HocuspocusProvider.ts

@@ -182,6 +182,8 @@ export class HocuspocusProvider extends EventEmitter {
 
   isSynced = false
 
+  unsyncedChanges = 0
+
   isAuthenticated = false
 
   lastMessageReceived = 0
@@ -259,11 +261,14 @@ export class HocuspocusProvider extends EventEmitter {
     this.configuration = { ...this.configuration, ...configuration }
   }
 
+  boundConnect = this.connect.bind(this)
+
   async connect() {
     if (this.status === WebSocketStatus.Connected) {
       return
     }
 
+    this.unsyncedChanges = 0 // set to 0 in case we got reconnected
     this.shouldConnect = true
     this.subscribeToBroadcastChannel()
 
@@ -344,6 +349,10 @@ export class HocuspocusProvider extends EventEmitter {
     return this.configuration.awareness
   }
 
+  get hasUnsyncedChanges() {
+    return this.unsyncedChanges > 0
+  }
+
   checkConnection() {
     // Don’t check the connection when it’s not even established
     if (this.status !== WebSocketStatus.Connected) {
@@ -373,15 +382,19 @@ export class HocuspocusProvider extends EventEmitter {
     this.send(SyncStepOneMessage, { document: this.document })
   }
 
+  boundBeforeUnload = this.beforeUnload.bind(this)
+
+  beforeUnload() {
+    removeAwarenessStates(this.awareness, [this.document.clientID], 'window unload')
+  }
+
   registerEventListeners() {
     if (typeof window === 'undefined') {
       return
     }
 
-    window.addEventListener('online', this.connect.bind(this))
-    window.addEventListener('beforeunload', () => {
-      removeAwarenessStates(this.awareness, [this.document.clientID], 'window unload')
-    })
+    window.addEventListener('online', this.boundConnect)
+    window.addEventListener('beforeunload', this.boundBeforeUnload)
   }
 
   documentUpdateHandler(update: Uint8Array, origin: any) {
@@ -389,6 +402,7 @@ export class HocuspocusProvider extends EventEmitter {
       return
     }
 
+    this.unsyncedChanges += 1
     this.send(UpdateMessage, { update }, true)
   }
 
@@ -605,13 +619,16 @@ export class HocuspocusProvider extends EventEmitter {
       return
     }
 
-    window.removeEventListener('online', this.connect.bind(this))
+    window.removeEventListener('online', this.boundConnect)
+    window.removeEventListener('beforeunload', this.boundBeforeUnload)
   }
 
   get broadcastChannel() {
     return `${this.serverUrl}/${this.configuration.name}`
   }
 
+  boundBroadcastChannelSubscriber = this.broadcastChannelSubscriber.bind(this)
+
   broadcastChannelSubscriber(data: ArrayBuffer) {
     this.mux(() => {
       const message = new IncomingMessage(data)
@@ -623,7 +640,7 @@ export class HocuspocusProvider extends EventEmitter {
 
   subscribeToBroadcastChannel() {
     if (!this.subscribedToBroadcastChannel) {
-      bc.subscribe(this.broadcastChannel, this.broadcastChannelSubscriber.bind(this))
+      bc.subscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber)
       this.subscribedToBroadcastChannel = true
     }
 
@@ -644,7 +661,7 @@ export class HocuspocusProvider extends EventEmitter {
     }, true)
 
     if (this.subscribedToBroadcastChannel) {
-      bc.unsubscribe(this.broadcastChannel, this.broadcastChannelSubscriber.bind(this))
+      bc.unsubscribe(this.broadcastChannel, this.boundBroadcastChannelSubscriber)
       this.subscribedToBroadcastChannel = false
     }
   }

package/src/MessageReceiver.ts

@@ -1,5 +1,5 @@
 import * as awarenessProtocol from 'y-protocols/awareness'
-import { readSyncMessage, messageYjsSyncStep2 } from 'y-protocols/sync'
+import { readSyncMessage, messageYjsSyncStep2, messageYjsUpdate } from 'y-protocols/sync'
 import { readAuthMessage } from '@hocuspocus/common'
 import { MessageType } from './types'
 import { HocuspocusProvider } from './HocuspocusProvider'
@@ -75,9 +75,15 @@ export class MessageReceiver {
     )
 
     // Synced once we receive Step2
-    if (emitSynced && syncMessageType === messageYjsSyncStep2) {
+    if (emitSynced && (syncMessageType === messageYjsSyncStep2)) {
       provider.synced = true
     }
+
+    if (syncMessageType === messageYjsUpdate || syncMessageType === messageYjsSyncStep2) {
+      if (provider.unsyncedChanges > 0) {
+        provider.unsyncedChanges -= 1
+      }
+    }
   }
 
   private applyAwarenessMessage(provider: HocuspocusProvider) {

package/dist/packages/extension-redis/src/RedisCluster.d.ts

@@ -1,4 +0,0 @@
-import { Redis } from './Redis';
-export declare class RedisCluster extends Redis {
-    cluster: boolean;
-}

package/dist/tests/extension-redis/onSynced.d.ts

@@ -1 +0,0 @@
-export {};