@hocuspocus/extension-redis 3.0.0-rc.0 → 3.0.4-rc.0

package/src/Redis.ts

@@ -17,7 +17,6 @@ import {
   IncomingMessage,
   OutgoingMessage,
   MessageReceiver,
-  Debugger,
 } from '@hocuspocus/server'
 
 export type RedisInstance = RedisClient.Cluster | RedisClient.Redis
@@ -98,19 +97,22 @@ export class Redis implements Extension {
 
   locks = new Map<string, Redlock.Lock>()
 
-  logger: Debugger
-
   messagePrefix: Buffer
 
+  /**
+   * When we have a high frequency of updates to a document we don't need tons of setTimeouts
+   * piling up, so we'll track them to keep it to the most recent per document.
+   */
+  private pendingDisconnects = new Map<string, NodeJS.Timeout>()
+
+  private pendingAfterStoreDocumentResolves = new Map<string, { timeout: NodeJS.Timeout; resolve:() => void }>()
+
   public constructor(configuration: Partial<Configuration>) {
     this.configuration = {
       ...this.configuration,
       ...configuration,
     }
 
-    // We’ll replace that in the onConfigure hook with the global instance.
-    this.logger = new Debugger()
-
     // Create Redis instance
     const {
       port,
@@ -145,7 +147,6 @@ export class Redis implements Extension {
   }
 
   async onConfigure({ instance }: onConfigurePayload) {
-    this.logger = instance.debugger
     this.instance = instance
   }
 
@@ -262,9 +263,27 @@ export class Redis implements Extension {
     // if the change was initiated by a directConnection, we need to delay this hook to make sure sync can finish first.
     // for provider connections, this usually happens in the onDisconnect hook
     if (socketId === 'server') {
-      await new Promise(resolve => {
-        setTimeout(() => resolve(''), this.configuration.disconnectDelay)
+      const pending = this.pendingAfterStoreDocumentResolves.get(documentName)
+
+      if (pending) {
+        clearTimeout(pending.timeout)
+        pending.resolve()
+        this.pendingAfterStoreDocumentResolves.delete(documentName)
+      }
+
+      let resolveFunction: () => void = () => {}
+      const delayedPromise = new Promise<void>(resolve => {
+        resolveFunction = resolve
       })
+
+      const timeout = setTimeout(() => {
+        this.pendingAfterStoreDocumentResolves.delete(documentName)
+        resolveFunction()
+      }, this.configuration.disconnectDelay)
+
+      this.pendingAfterStoreDocumentResolves.set(documentName, { timeout, resolve: resolveFunction })
+
+      await delayedPromise
     }
   }
 
@@ -303,14 +322,11 @@ export class Redis implements Extension {
     const document = this.instance.documents.get(documentName)
 
     if (!document) {
-      // What does this mean? Why are we subscribed to this document?
-      this.logger.log(`Received message for unknown document ${documentName}`)
       return
     }
 
     new MessageReceiver(
       message,
-      this.logger,
       this.redisTransactionOrigin,
     ).apply(document, undefined, reply => {
       return this.pub.publishBuffer(
@@ -334,9 +350,18 @@ export class Redis implements Extension {
    * no one connected anymore.
    */
   public onDisconnect = async ({ documentName }: onDisconnectPayload) => {
+    const pending = this.pendingDisconnects.get(documentName)
+
+    if (pending) {
+      clearTimeout(pending)
+      this.pendingDisconnects.delete(documentName)
+    }
+
     const disconnect = () => {
       const document = this.instance.documents.get(documentName)
 
+      this.pendingDisconnects.delete(documentName)
+
       // Do nothing, when other users are still connected to the document.
       if (!document || document.getConnectionsCount() > 0) {
         return
@@ -352,7 +377,8 @@ export class Redis implements Extension {
       this.instance.unloadDocument(document)
     }
     // Delay the disconnect procedure to allow last minute syncs to happen
-    setTimeout(disconnect, this.configuration.disconnectDelay)
+    const timeout = setTimeout(disconnect, this.configuration.disconnectDelay)
+    this.pendingDisconnects.set(documentName, timeout)
   }
 
   async beforeBroadcastStateless(data: beforeBroadcastStatelessPayload) {

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

@@ -1,64 +0,0 @@
-import type { AbstractType, YArrayEvent } from 'yjs';
-import * as Y from 'yjs';
-import type { HocuspocusProviderConfiguration } from './HocuspocusProvider.js';
-import { HocuspocusProvider } from './HocuspocusProvider.js';
-import { TiptapCollabProviderWebsocket } from './TiptapCollabProviderWebsocket.js';
-import type { TCollabComment, TCollabThread, THistoryVersion } from './types.js';
-export type TiptapCollabProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & (Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'websocketProvider'>> | Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'appId'>> | Required<Pick<AdditionalTiptapCollabProviderConfiguration, 'baseUrl'>>) & Pick<AdditionalTiptapCollabProviderConfiguration, 'user'>;
-export interface AdditionalTiptapCollabProviderConfiguration {
-    /**
-     * A Hocuspocus Cloud App ID, get one here: https://cloud.tiptap.dev
-     */
-    appId?: string;
-    /**
-     * If you are using the on-premise version of TiptapCollab, put your baseUrl here (e.g. https://collab.yourdomain.com)
-     */
-    baseUrl?: string;
-    websocketProvider?: TiptapCollabProviderWebsocket;
-    user?: string;
-}
-export declare class TiptapCollabProvider extends HocuspocusProvider {
-    tiptapCollabConfigurationPrefix: string;
-    userData?: Y.PermanentUserData;
-    constructor(configuration: TiptapCollabProviderConfiguration);
-    /**
-     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
-     */
-    createVersion(name?: string): void;
-    /**
-     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
-     */
-    revertToVersion(targetVersion: number): void;
-    /**
-     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
-     *
-     * The server will reply with a stateless message (THistoryVersionPreviewEvent)
-     */
-    previewVersion(targetVersion: number): void;
-    /**
-     * note: this will only work if your server loaded @hocuspocus-pro/extension-history, or if you are on a Tiptap business plan.
-     */
-    getVersions(): THistoryVersion[];
-    watchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['observe']>[0]): void;
-    unwatchVersions(callback: Parameters<AbstractType<YArrayEvent<THistoryVersion>>['unobserve']>[0]): void;
-    isAutoVersioning(): boolean;
-    enableAutoVersioning(): 1;
-    disableAutoVersioning(): 0;
-    private getYThreads;
-    getThreads<Data, CommentData>(): TCollabThread<Data, CommentData>[];
-    private getThreadIndex;
-    getThread<Data, CommentData>(id: string): TCollabThread<Data, CommentData> | null;
-    private getYThread;
-    createThread(data: Omit<TCollabThread, 'id' | 'createdAt' | 'updatedAt' | 'comments'>): TCollabThread;
-    updateThread(id: TCollabThread['id'], data: Partial<Pick<TCollabThread, 'data'> & {
-        resolvedAt: TCollabThread['resolvedAt'] | null;
-    }>): TCollabThread;
-    deleteThread(id: TCollabThread['id']): void;
-    getThreadComments(threadId: TCollabThread['id']): TCollabComment[] | null;
-    getThreadComment(threadId: TCollabThread['id'], commentId: TCollabComment['id']): TCollabComment | null;
-    addComment(threadId: TCollabThread['id'], data: Omit<TCollabComment, 'id' | 'updatedAt' | 'createdAt'>): TCollabThread;
-    updateComment(threadId: TCollabThread['id'], commentId: TCollabComment['id'], data: Partial<Pick<TCollabComment, 'data' | 'content'>>): TCollabThread;
-    deleteComment(threadId: TCollabThread['id'], commentId: TCollabComment['id']): TCollabThread | null | undefined;
-    watchThreads(callback: () => void): void;
-    unwatchThreads(callback: () => void): void;
-}

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

@@ -1,20 +0,0 @@
-import type { CompleteHocuspocusProviderWebsocketConfiguration } from './HocuspocusProviderWebsocket.js';
-import { HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket.js';
-export type TiptapCollabProviderWebsocketConfiguration = Partial<CompleteHocuspocusProviderWebsocketConfiguration> & AdditionalTiptapCollabProviderWebsocketConfiguration;
-export interface AdditionalTiptapCollabProviderWebsocketConfiguration {
-    /**
-     * A Hocuspocus Cloud App ID, get one here: https://cloud.tiptap.dev
-     */
-    appId?: string;
-    /**
-     * If you are using the on-premise version of TiptapCollab, put your baseUrl here (e.g. https://collab.yourdomain.com)
-     */
-    baseUrl?: string;
-    /**
-     * Only fill this if you are using Tiptap Collab HA.
-     */
-    shardKey?: string;
-}
-export declare class TiptapCollabProviderWebsocket extends HocuspocusProviderWebsocket {
-    constructor(configuration: TiptapCollabProviderWebsocketConfiguration);
-}

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

@@ -1,14 +0,0 @@
-export declare class Debugger {
-    logs: any[];
-    listen: boolean;
-    output: boolean;
-    enable(): void;
-    disable(): void;
-    verbose(): void;
-    quiet(): void;
-    log(message: any): this;
-    flush(): this;
-    get(): {
-        logs: any[];
-    };
-}

package/dist/tests/server/getMessageLogs.d.ts

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

package/dist/tests/server/requiresAuthentication.d.ts

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