@hocuspocus/extension-webhook 2.1.0 → 2.2.0

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

@@ -0,0 +1,56 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import WebSocket from 'ws';
+import { Debugger } from './Debugger.js';
+import Document from './Document.js';
+import { Hocuspocus } from './Hocuspocus.js';
+import { onDisconnectPayload } from './types.js';
+/**
+ * The `ClientConnection` class is responsible for handling an incoming WebSocket
+ *
+ * TODO-refactor:
+ * - use event handlers instead of calling hooks directly, hooks should probably be called from Hocuspocus.ts
+ */
+export declare class ClientConnection {
+    private readonly websocket;
+    private readonly request;
+    private readonly documentProvider;
+    private readonly hooks;
+    private readonly debuggerTool;
+    private readonly opts;
+    private readonly defaultContext;
+    private readonly documentConnections;
+    private readonly incomingMessageQueue;
+    private readonly documentConnectionsEstablished;
+    private readonly hookPayloads;
+    private readonly callbacks;
+    private readonly closeIdleConnectionTimeout;
+    private readonly socketId;
+    /**
+      * The `ClientConnection` class receives incoming WebSocket connections,
+      * runs all hooks:
+      *
+      *  - onConnect for all connections
+      *  - onAuthenticate only if required
+      *
+      * … and if nothings fails it’ll fully establish the connection and
+      * load the Document then.
+      */
+    constructor(websocket: WebSocket, request: IncomingMessage, documentProvider: {
+        createDocument: Hocuspocus['createDocument'];
+    }, hooks: Hocuspocus['hooks'], debuggerTool: Debugger, opts: {
+        requiresAuthentication: boolean;
+        timeout: number;
+    }, defaultContext?: any);
+    /**
+     * Set a callback that will be triggered when the connection is closed
+     */
+    onClose(callback: (document: Document, payload: onDisconnectPayload) => void): ClientConnection;
+    /**
+     * Create a new connection by the given request and document
+     */
+    private createConnection;
+    private setUpNewConnection;
+    private handleQueueingMessage;
+    private messageHandler;
+}

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

@@ -1,6 +1,7 @@
 import Document from './Document.js';
 import type { Hocuspocus } from './Hocuspocus.js';
-export declare class DirectConnection {
+import type { DirectConnection as DirectConnectionInterface } from './types';
+export declare class DirectConnection implements DirectConnectionInterface {
     document: Document | null;
     instance: Hocuspocus;
     context: any;

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

@@ -1,11 +1,11 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { IncomingMessage, Server as HTTPServer } from 'http';
+import { Server as HTTPServer, IncomingMessage } from 'http';
 import WebSocket, { AddressInfo, WebSocketServer } from 'ws';
-import { Configuration, HookName, HookPayload, onListenPayload, onStoreDocumentPayload } from './types.js';
-import Document from './Document.js';
 import { Debugger } from './Debugger.js';
 import { DirectConnection } from './DirectConnection.js';
+import Document from './Document.js';
+import { Configuration, ConnectionConfiguration, HookName, HookPayload, onListenPayload, onStoreDocumentPayload } from './types.js';
 export declare const defaultConfiguration: {
     name: null;
     port: number;
@@ -69,7 +69,7 @@ export declare class Hocuspocus {
      * … and if nothings fails it’ll fully establish the connection and
      * load the Document then.
      */
-    handleConnection(incoming: WebSocket, request: IncomingMessage, context?: any): void;
+    handleConnection(incoming: WebSocket, request: IncomingMessage, defaultContext?: any): void;
     /**
      * Handle update of the given document
      */
@@ -85,21 +85,13 @@ export declare class Hocuspocus {
     /**
      * Create a new document by the given request
      */
-    private createDocument;
-    /**
-     * Create a new connection by the given request and document
-     */
-    private createConnection;
+    createDocument(documentName: string, request: Partial<Pick<IncomingMessage, 'headers' | 'url'>>, socketId: string, connection: ConnectionConfiguration, context?: any): Promise<Document>;
     storeDocumentHooks(document: Document, hookPayload: onStoreDocumentPayload): void;
     /**
      * Run the given hook on all configured extensions.
      * Runs the given callback after each hook.
      */
     hooks(name: HookName, payload: HookPayload, callback?: Function | null): Promise<any>;
-    /**
-     * Get parameters by the given request
-     */
-    private static getParameters;
     enableDebugging(): void;
     enableMessageLogging(): void;
     disableLogging(): void;

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

@@ -264,3 +264,7 @@ export interface onConfigurePayload {
     configuration: Configuration;
     version: string;
 }
+export interface DirectConnection {
+    transact(transaction: (document: Document) => void): Promise<void>;
+    disconnect(): void;
+}

package/dist/packages/server/src/util/getParameters.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { URLSearchParams } from 'url';
+/**
+   * Get parameters by the given request
+   */
+export declare function getParameters(request?: Pick<IncomingMessage, 'url'>): URLSearchParams;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hocuspocus/extension-webhook",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "hocuspocus webhook extension",
   "homepage": "https://hocuspocus.dev",
   "keywords": [
@@ -30,9 +30,9 @@
     "dist"
   ],
   "dependencies": {
-    "@hocuspocus/common": "^2.1.0",
-    "@hocuspocus/server": "^2.1.0",
-    "@hocuspocus/transformer": "^2.1.0",
+    "@hocuspocus/common": "^2.2.0",
+    "@hocuspocus/server": "^2.2.0",
+    "@hocuspocus/transformer": "^2.2.0",
     "axios": "^1.2.2"
   },
   "peerDependencies": {