@hocuspocus/extension-webhook 1.0.0-alpha.34

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

@@ -0,0 +1,19 @@
+import { Decoder } from 'lib0/decoding';
+import { Encoder } from 'lib0/encoding';
+import { MessageType } from './types';
+export declare class IncomingMessage {
+    /**
+     * Access to the received message.
+     */
+    decoder: Decoder;
+    /**
+     * Access to the reply.
+     */
+    encoder: Encoder;
+    constructor(input: any);
+    readVarUint8Array(): Uint8Array;
+    readVarUint(): number;
+    toUint8Array(): Uint8Array;
+    writeVarUint(type: MessageType): void;
+    get length(): number;
+}

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

@@ -0,0 +1,10 @@
+import Connection from './Connection';
+import { IncomingMessage } from './IncomingMessage';
+import { MessageLogger } from './Debugger';
+export declare class MessageReceiver {
+    message: IncomingMessage;
+    debugger: MessageLogger;
+    constructor(message: IncomingMessage);
+    apply(connection: Connection): void;
+    readSyncMessage(message: IncomingMessage, connection: Connection): 0 | 1 | 2;
+}

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

@@ -0,0 +1,16 @@
+import { Encoder } from 'lib0/encoding';
+import { Awareness } from 'y-protocols/awareness';
+import Document from './Document';
+export declare class OutgoingMessage {
+    encoder: Encoder;
+    type?: number;
+    category?: string;
+    constructor();
+    createSyncMessage(): OutgoingMessage;
+    createAwarenessUpdateMessage(awareness: Awareness, changedClients?: Array<any>): OutgoingMessage;
+    writeAuthenticated(): OutgoingMessage;
+    writePermissionDenied(reason: string): OutgoingMessage;
+    writeFirstSyncStepFor(document: Document): OutgoingMessage;
+    writeUpdate(update: Uint8Array): OutgoingMessage;
+    toUint8Array(): Uint8Array;
+}

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

@@ -0,0 +1,2 @@
+export * from './Hocuspocus';
+export * from './types';

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

@@ -0,0 +1,133 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders, IncomingMessage, ServerResponse } from 'http';
+import { URLSearchParams } from 'url';
+import { Socket } from 'net';
+import Document from './Document';
+import { Hocuspocus } from './Hocuspocus';
+export declare enum MessageType {
+    Unknown = -1,
+    Sync = 0,
+    Awareness = 1,
+    Auth = 2
+}
+/**
+ * State of the WebSocket connection.
+ * https://developer.mozilla.org/de/docs/Web/API/WebSocket/readyState
+ */
+export declare enum WsReadyStates {
+    Connecting = 0,
+    Open = 1,
+    Closing = 2,
+    Closed = 3
+}
+export interface AwarenessUpdate {
+    added: Array<any>;
+    updated: Array<any>;
+    removed: Array<any>;
+}
+export interface ConnectionConfig {
+    readOnly: boolean;
+    isAuthenticated: boolean;
+}
+export interface Extension {
+    onAuthenticate?(data: onAuthenticatePayload): Promise<any>;
+    onChange?(data: onChangePayload): Promise<any>;
+    onConnect?(data: onConnectPayload): Promise<any>;
+    onConfigure?(data: onConfigurePayload): Promise<any>;
+    onCreateDocument?(data: onCreateDocumentPayload): Promise<any>;
+    onDestroy?(data: onDestroyPayload): Promise<any>;
+    onDisconnect?(data: onDisconnectPayload): Promise<any>;
+    onListen?(data: onListenPayload): Promise<any>;
+    onRequest?(data: onRequestPayload): Promise<any>;
+    onUpgrade?(data: onUpgradePayload): Promise<any>;
+}
+export interface Configuration extends Extension {
+    /**
+     * A list of hocuspocus extenions.
+     */
+    extensions: Array<Extension>;
+    /**
+     * The port which the server listens on.
+     */
+    port: number | null;
+    /**
+     * Defines in which interval the server sends a ping, and closes the connection when no pong is sent back.
+     */
+    timeout: number;
+}
+export interface onAuthenticatePayload {
+    documentName: string;
+    instance: Hocuspocus;
+    requestHeaders: IncomingHttpHeaders;
+    requestParameters: URLSearchParams;
+    socketId: string;
+    token: string;
+    connection: ConnectionConfig;
+}
+export interface onConnectPayload {
+    documentName: string;
+    instance: Hocuspocus;
+    request: IncomingMessage;
+    requestHeaders: IncomingHttpHeaders;
+    requestParameters: URLSearchParams;
+    socketId: string;
+    connection: ConnectionConfig;
+}
+export interface onCreateDocumentPayload {
+    context: any;
+    document: Document;
+    documentName: string;
+    instance: Hocuspocus;
+    requestHeaders: IncomingHttpHeaders;
+    requestParameters: URLSearchParams;
+    socketId: string;
+    connection: ConnectionConfig;
+}
+export interface onChangePayload {
+    clientsCount: number;
+    context: any;
+    document: Document;
+    documentName: string;
+    instance: Hocuspocus;
+    requestHeaders: IncomingHttpHeaders;
+    requestParameters: URLSearchParams;
+    update: Uint8Array;
+    socketId: string;
+}
+export interface onDisconnectPayload {
+    clientsCount: number;
+    context: any;
+    document: Document;
+    documentName: string;
+    instance: Hocuspocus;
+    requestHeaders: IncomingHttpHeaders;
+    requestParameters: URLSearchParams;
+    socketId: string;
+}
+export interface onRequestPayload {
+    request: IncomingMessage;
+    response: ServerResponse;
+    instance: Hocuspocus;
+}
+export interface onUpgradePayload {
+    head: any;
+    request: IncomingMessage;
+    socket: Socket;
+    instance: Hocuspocus;
+}
+export interface onListenPayload {
+    port: number;
+}
+export interface onDestroyPayload {
+    instance: Hocuspocus;
+}
+export interface onConfigurePayload {
+    configuration: Configuration;
+    version: string;
+    yjsVersion: string;
+    instance: Hocuspocus;
+}
+export interface CloseEvent {
+    code: number;
+    reason: string;
+}

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

@@ -0,0 +1,20 @@
+import { Extension, onConnectPayload } from '@hocuspocus/server';
+export interface Configuration {
+    throttle: number | null | false;
+    banTime: number;
+}
+export declare class Throttle implements Extension {
+    configuration: Configuration;
+    connectionsByIp: Map<string, Array<number>>;
+    bannedIps: Map<string, number>;
+    /**
+     * Throttle requests
+     * @private
+     */
+    private throttle;
+    /**
+     * onConnect hook
+     * @param data
+     */
+    onConnect(data: onConnectPayload): Promise<any>;
+}

package/dist/packages/transformer/src/Prosemirror.d.ts

@@ -0,0 +1,11 @@
+import { Doc } from 'yjs';
+import { Schema } from 'prosemirror-model';
+import { Transformer } from './types';
+declare class Prosemirror implements Transformer {
+    defaultSchema: Schema;
+    schema(schema: Schema): Prosemirror;
+    fromYdoc(document: Doc, fieldName?: string | Array<string>): any;
+    toYdoc(document: any, fieldName?: string | Array<string>, schema?: Schema): Doc;
+}
+export declare const ProsemirrorTransformer: Prosemirror;
+export {};

package/dist/packages/transformer/src/Tiptap.d.ts

@@ -0,0 +1,10 @@
+import { Doc } from 'yjs';
+import { Extensions } from '@tiptap/core/dist/packages/core/src/types';
+import { Transformer } from './types';
+export declare class Tiptap implements Transformer {
+    defaultExtensions: Extensions;
+    extensions(extensions: Extensions): Tiptap;
+    fromYdoc(document: Doc, fieldName?: string | Array<string>): any;
+    toYdoc(document: any, fieldName?: string | Array<string>, extensions?: Extensions): Doc;
+}
+export declare const TiptapTransformer: Tiptap;

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

@@ -0,0 +1,3 @@
+export * from './Prosemirror';
+export * from './Tiptap';
+export * from './types';

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

@@ -0,0 +1,5 @@
+import { Doc } from 'yjs';
+export interface Transformer {
+    fromYdoc: (document: Doc, fieldName?: string | Array<string>) => any;
+    toYdoc: (document: any, fieldName: string) => Doc;
+}

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

@@ -0,0 +1,59 @@
+/// <reference types="node" />
+import { Extension, onChangePayload, onConnectPayload, onCreateDocumentPayload, onDisconnectPayload } from '@hocuspocus/server';
+import { Doc } from 'yjs';
+import { Transformer } from '@hocuspocus/transformer';
+import { AxiosResponse } from 'axios';
+import Timeout = NodeJS.Timeout;
+export declare enum Events {
+    onChange = "change",
+    onConnect = "connect",
+    onCreate = "create",
+    onDisconnect = "disconnect"
+}
+export interface Configuration {
+    debounce: number | false | null;
+    debounceMaxWait: number;
+    secret: string;
+    transformer: Transformer | {
+        toYdoc: (document: any) => Doc;
+        fromYdoc: (document: Doc) => any;
+    };
+    url: string;
+    events: Array<Events>;
+}
+export declare class Webhook implements Extension {
+    configuration: Configuration;
+    debounced: Map<string, {
+        timeout: Timeout;
+        start: number;
+    }>;
+    /**
+     * Constructor
+     */
+    constructor(configuration?: Partial<Configuration>);
+    /**
+     * Create a signature for the response body
+     */
+    createSignature(body: string): string;
+    /**
+     * debounce the given function, using the given identifier
+     */
+    debounce(id: string, func: Function): void;
+    /**
+     * Send a request to the given url containing the given data
+     */
+    sendRequest(event: Events, payload: any): Promise<AxiosResponse<any>>;
+    /**
+     * onChange hook
+     */
+    onChange(data: onChangePayload): Promise<void>;
+    /**
+     * onCreateDocument hook
+     */
+    onCreateDocument(data: onCreateDocumentPayload): Promise<void>;
+    /**
+     * onConnect hook
+     */
+    onConnect(data: onConnectPayload): Promise<any>;
+    onDisconnect(data: onDisconnectPayload): Promise<void>;
+}

package/dist/shared/protocols/auth.d.ts

@@ -0,0 +1,6 @@
+import * as encoding from 'lib0/encoding';
+import * as decoding from 'lib0/decoding';
+export declare const writeAuthentication: (encoder: encoding.Encoder, auth: string) => void;
+export declare const writePermissionDenied: (encoder: encoding.Encoder, reason: string) => void;
+export declare const writeAuthenticated: (encoder: encoding.Encoder) => void;
+export declare const readAuthMessage: (decoder: decoding.Decoder, permissionDeniedHandler: (reason: string) => void, authenticatedHandler: () => void) => void;

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@hocuspocus/extension-webhook",
+  "version": "1.0.0-alpha.34",
+  "description": "hocuspocus webhook extension",
+  "homepage": "https://hocuspocus.dev",
+  "keywords": [
+    "hocuspocus",
+    "webhook",
+    "api",
+    "rest",
+    "yjs"
+  ],
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/hocuspocus-webhook.esm.js",
+  "module": "dist/hocuspocus-webhook.esm.js",
+  "types": "dist/packages/webhook/src/index.d.ts",
+  "exports": {
+    "import": "./dist/hocuspocus-webhook.esm.js",
+    "require": "./dist/hocuspocus-webhook.cjs"
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "dependencies": {
+    "@hocuspocus/server": "^1.0.0-alpha.69",
+    "@hocuspocus/transformer": "^1.0.0-alpha.14",
+    "axios": "^0.21.1"
+  },
+  "gitHead": "d84b5516f65dfe096fd6c633f96309a6f65a9811"
+}

package/src/index.ts

@@ -0,0 +1,197 @@
+import { createHmac } from 'crypto'
+import {
+  Extension,
+  onChangePayload,
+  onConnectPayload,
+  onCreateDocumentPayload,
+  onDisconnectPayload,
+} from '@hocuspocus/server'
+import { Doc } from 'yjs'
+import { TiptapTransformer, Transformer } from '@hocuspocus/transformer'
+import axios, { AxiosResponse } from 'axios'
+import Timeout = NodeJS.Timeout
+
+export enum Events {
+  onChange = 'change',
+  onConnect = 'connect',
+  onCreate = 'create',
+  onDisconnect = 'disconnect',
+}
+
+export interface Configuration {
+  debounce: number | false | null,
+  debounceMaxWait: number,
+  secret: string,
+  transformer: Transformer | {
+    toYdoc: (document: any) => Doc,
+    fromYdoc: (document: Doc) => any,
+  },
+  url: string,
+  events: Array<Events>,
+}
+
+export class Webhook implements Extension {
+
+  configuration: Configuration = {
+    debounce: 2000,
+    debounceMaxWait: 10000,
+    secret: '',
+    transformer: TiptapTransformer,
+    url: '',
+    events: [
+      Events.onChange,
+    ],
+  }
+
+  debounced: Map<string, { timeout: Timeout, start: number }> = new Map()
+
+  /**
+   * Constructor
+   */
+  constructor(configuration?: Partial<Configuration>) {
+    this.configuration = {
+      ...this.configuration,
+      ...configuration,
+    }
+
+    if (!this.configuration.url) {
+      throw new Error('url is required!')
+    }
+  }
+
+  /**
+   * Create a signature for the response body
+   */
+  createSignature(body: string): string {
+    const hmac = createHmac('sha256', this.configuration.secret)
+
+    return `sha256=${hmac.update(body).digest('hex')}`
+  }
+
+  /**
+   * debounce the given function, using the given identifier
+   */
+  debounce(id: string, func: Function) {
+    const old = this.debounced.get(id)
+    const start = old?.start || Date.now()
+
+    const run = () => {
+      this.debounced.delete(id)
+      func()
+    }
+
+    if (old?.timeout) clearTimeout(old.timeout)
+    if (Date.now() - start >= this.configuration.debounceMaxWait) return run()
+
+    this.debounced.set(id, {
+      start,
+      timeout: setTimeout(run, <number> this.configuration.debounce),
+    })
+  }
+
+  /**
+   * Send a request to the given url containing the given data
+   */
+  async sendRequest(event: Events, payload: any) {
+    const json = JSON.stringify({ event, payload })
+
+    return axios.post(
+      this.configuration.url,
+      json,
+      { headers: { 'X-Hocuspocus-Signature-256': this.createSignature(json) } },
+    )
+  }
+
+  /**
+   * onChange hook
+   */
+  async onChange(data: onChangePayload) {
+    if (!this.configuration.events.includes(Events.onChange)) {
+      return
+    }
+
+    const save = () => {
+      this.sendRequest(Events.onChange, {
+        document: this.configuration.transformer.fromYdoc(data.document),
+        documentName: data.documentName,
+        context: data.context,
+        requestHeaders: data.requestHeaders,
+        requestParameters: Object.fromEntries(data.requestParameters.entries()),
+      })
+    }
+
+    if (!this.configuration.debounce) {
+      return save()
+    }
+
+    this.debounce(data.documentName, save)
+  }
+
+  /**
+   * onCreateDocument hook
+   */
+  async onCreateDocument(data: onCreateDocumentPayload) {
+    if (!this.configuration.events.includes(Events.onCreate)) {
+      return
+    }
+
+    const response = <AxiosResponse> await this.sendRequest(Events.onCreate, {
+      documentName: data.documentName,
+      requestHeaders: data.requestHeaders,
+      requestParameters: Object.fromEntries(data.requestParameters.entries()),
+    })
+
+    if (response.status !== 200 || !response.data) return
+
+    const document = typeof response.data === 'string'
+      ? JSON.parse(response.data)
+      : response.data
+
+    // eslint-disable-next-line guard-for-in,no-restricted-syntax
+    for (const fieldName in document) {
+      if (data.document.isEmpty(fieldName)) {
+        data.document.merge(
+          this.configuration.transformer.toYdoc(document[fieldName], fieldName),
+        )
+      }
+    }
+  }
+
+  /**
+   * onConnect hook
+   */
+  async onConnect(data: onConnectPayload) {
+    if (!this.configuration.events.includes(Events.onConnect)) {
+      return
+    }
+
+    try {
+      const response = <AxiosResponse> await this.sendRequest(Events.onConnect, {
+        documentName: data.documentName,
+        requestHeaders: data.requestHeaders,
+        requestParameters: Object.fromEntries(data.requestParameters.entries()),
+      })
+
+      return typeof response.data === 'string'
+        ? JSON.parse(response.data)
+        : response.data
+    } catch (e) {
+      // eslint-disable-next-line no-throw-literal
+      throw null
+    }
+  }
+
+  async onDisconnect(data: onDisconnectPayload) {
+    if (!this.configuration.events.includes(Events.onConnect)) {
+      return
+    }
+
+    await this.sendRequest(Events.onDisconnect, {
+      documentName: data.documentName,
+      requestHeaders: data.requestHeaders,
+      requestParameters: Object.fromEntries(data.requestParameters.entries()),
+      context: data.context,
+    })
+  }
+
+}