@hocuspocus/provider 1.0.0-alpha.27 → 1.0.0-alpha.31

package/dist/packages/common/src/CloseEvents.d.ts

@@ -0,0 +1,23 @@
+export interface CloseEvent {
+    code: number;
+    reason: string;
+}
+/**
+ * The server successfully processed the request, asks that the requester reset
+ * its document view, and is not returning any content.
+ */
+export declare const ResetConnection: CloseEvent;
+/**
+ * Similar to Forbidden, but specifically for use when authentication is required and has
+ * failed or has not yet been provided.
+ */
+export declare const Unauthorized: CloseEvent;
+/**
+ * The request contained valid data and was understood by the server, but the server
+ * is refusing action.
+ */
+export declare const Forbidden: CloseEvent;
+/**
+ * The server timed out waiting for the request.
+ */
+export declare const ConnectionTimeout: CloseEvent;

package/dist/packages/common/src/awarenessStatesToArray.d.ts

@@ -0,0 +1,3 @@
+export declare const awarenessStatesToArray: (states: Map<number, Record<string, any>>) => {
+    clientId: number;
+}[];

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

@@ -1 +1,3 @@
 export * from './auth';
+export * from './CloseEvents';
+export * from './awarenessStatesToArray';

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

@@ -0,0 +1,32 @@
+import { Extension, onChangePayload, onLoadDocumentPayload, storePayload } 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>;
+    /**
+     * Pass a function to store updates in your database.
+     */
+    store: (data: storePayload) => void;
+}
+export declare class Database implements Extension {
+    /**
+     * Default configuration
+     */
+    configuration: DatabaseConfiguration;
+    /**
+     * Constructor
+     */
+    constructor(configuration: Partial<DatabaseConfiguration>);
+    /**
+     * Get stored data from the database.
+     */
+    onLoadDocument({ document, documentName }: onLoadDocumentPayload): Promise<any>;
+    /**
+     * Store new updates in the database.
+     */
+    onStoreDocument(data: onChangePayload): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export * from './Database';

package/dist/packages/extension-logger/src/Logger.d.ts

@@ -14,6 +14,10 @@ export interface LoggerConfiguration {
      * Whether to log something for the `onChange` hook.
      */
     onChange: boolean;
+    /**
+     * Whether to log something for the `onStoreDocument` hook.
+     */
+    onStoreDocument: boolean;
     /**
      * Whether to log something for the `onConnect` hook.
      */
@@ -53,6 +57,7 @@ export declare class Logger implements Extension {
     onConfigure(data: onConfigurePayload): Promise<void>;
     onLoadDocument(data: onLoadDocumentPayload): Promise<void>;
     onChange(data: onChangePayload): Promise<void>;
+    onStoreDocument(data: onDisconnectPayload): Promise<void>;
     onConnect(data: onConnectPayload): Promise<void>;
     onDisconnect(data: onDisconnectPayload): Promise<void>;
     onUpgrade(data: onUpgradePayload): Promise<void>;

package/dist/packages/extension-sqlite/src/SQLite.d.ts

@@ -0,0 +1,26 @@
+import { Database, DatabaseConfiguration } from '@hocuspocus/extension-database';
+import sqlite3 from 'sqlite3';
+export declare const schema = "CREATE TABLE IF NOT EXISTS \"documents\" (\n  \"name\" varchar(255) NOT NULL,\n  \"data\" blob NOT NULL,\n  UNIQUE(name)\n)";
+export declare const selectQuery = "\n  SELECT data FROM \"documents\" WHERE name = $name ORDER BY rowid DESC\n";
+export declare const upsertQuery = "\n  INSERT INTO \"documents\" (\"name\", \"data\") VALUES ($name, $data)\n    ON CONFLICT(name) DO UPDATE SET data = $data\n";
+export interface SQLiteConfiguration extends DatabaseConfiguration {
+    /**
+     * Valid values are filenames, ":memory:" for an anonymous in-memory database and an empty
+     * string for an anonymous disk-based database. Anonymous databases are not persisted and
+     * when closing the database handle, their contents are lost.
+     *
+     * https://github.com/mapbox/node-sqlite3/wiki/API#new-sqlite3databasefilename-mode-callback
+     */
+    database: string;
+    /**
+     * The database schema to create.
+     */
+    schema: string;
+}
+export declare class SQLite extends Database {
+    db?: sqlite3.Database;
+    configuration: SQLiteConfiguration;
+    constructor(configuration?: Partial<SQLiteConfiguration>);
+    onConfigure(): Promise<void>;
+    onListen(): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export * from './SQLite';

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

@@ -1,12 +1,16 @@
 import { Extension, onConnectPayload } from '@hocuspocus/server';
-export interface Configuration {
+export interface ThrottleConfiguration {
     throttle: number | null | false;
     banTime: number;
 }
 export declare class Throttle implements Extension {
-    configuration: Configuration;
+    configuration: ThrottleConfiguration;
     connectionsByIp: Map<string, Array<number>>;
     bannedIps: Map<string, number>;
+    /**
+     * Constructor
+     */
+    constructor(configuration?: Partial<ThrottleConfiguration>);
     /**
      * Throttle requests
      * @private

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

@@ -3,7 +3,6 @@ import { Extension, onChangePayload, onConnectPayload, onLoadDocumentPayload, on
 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",
@@ -24,7 +23,7 @@ export interface Configuration {
 export declare class Webhook implements Extension {
     configuration: Configuration;
     debounced: Map<string, {
-        timeout: Timeout;
+        timeout: NodeJS.Timeout;
         start: number;
     }>;
     /**
@@ -42,7 +41,7 @@ export declare class Webhook implements Extension {
     /**
      * Send a request to the given url containing the given data
      */
-    sendRequest(event: Events, payload: any): Promise<AxiosResponse<unknown, any>>;
+    sendRequest(event: Events, payload: any): Promise<AxiosResponse<any, any>>;
     /**
      * onChange hook
      */

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

@@ -5,5 +5,5 @@ export default class EventEmitter {
     on(event: string, fn: Function): this;
     protected emit(event: string, ...args: any): this;
     off(event: string, fn?: Function): this;
-    protected removeAllListeners(): void;
+    removeAllListeners(): void;
 }

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

@@ -1,10 +1,11 @@
-import { HocuspocusProvider, HocuspocusProviderOptions } from './HocuspocusProvider';
-export interface HocuspocusCloudProviderOptions extends HocuspocusProviderOptions {
+import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider';
+export declare type HocuspocusCloudProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & AdditionalHocuspocusCloudProviderConfiguration;
+export interface AdditionalHocuspocusCloudProviderConfiguration {
     /**
      * A Hocuspocus Cloud key, get one here: https://hocuspocus.cloud/
      */
     key: string;
 }
 export declare class HocuspocusCloudProvider extends HocuspocusProvider {
-    constructor(options: HocuspocusCloudProviderOptions);
+    constructor(configuration: HocuspocusCloudProviderConfiguration);
 }

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

@@ -1,16 +1,18 @@
 import * as Y from 'yjs';
 import { Awareness } from 'y-protocols/awareness';
 import * as mutex from 'lib0/mutex';
-import { Event, CloseEvent, MessageEvent } from 'ws';
+import type { Event, CloseEvent, MessageEvent } from 'ws';
 import EventEmitter from './EventEmitter';
 import { OutgoingMessage } from './OutgoingMessage';
 import { ConstructableOutgoingMessage } from './types';
+import { onAwarenessChangeParameters, onAwarenessUpdateParameters } from '.';
 export declare enum WebSocketStatus {
     Connecting = "connecting",
     Connected = "connected",
     Disconnected = "disconnected"
 }
-export interface HocuspocusProviderOptions {
+export declare type HocuspocusProviderConfiguration = Required<Pick<CompleteHocuspocusProviderConfiguration, 'url' | 'name'>> & Partial<CompleteHocuspocusProviderConfiguration>;
+export interface CompleteHocuspocusProviderConfiguration {
     /**
      * URL of your @hocuspocus/server instance
      */
@@ -98,15 +100,21 @@ export interface HocuspocusProviderOptions {
     onMessage: (event: MessageEvent) => void;
     onOutgoingMessage: (message: OutgoingMessage) => void;
     onStatus: (status: any) => void;
-    onSynced: () => void;
+    onSynced: ({ state }: {
+        state: boolean;
+    }) => void;
     onDisconnect: (event: CloseEvent) => void;
     onClose: (event: CloseEvent) => void;
     onDestroy: () => void;
-    onAwarenessUpdate: (states: any) => void;
-    onAwarenessChange: (states: any) => void;
+    onAwarenessUpdate: ({ states }: onAwarenessUpdateParameters) => void;
+    onAwarenessChange: ({ states }: onAwarenessChangeParameters) => void;
+    /**
+     * Don’t output any warnings.
+     */
+    quiet: boolean;
 }
 export declare class HocuspocusProvider extends EventEmitter {
-    options: HocuspocusProviderOptions;
+    configuration: CompleteHocuspocusProviderConfiguration;
     subscribedToBroadcastChannel: boolean;
     webSocket: WebSocket | null;
     shouldConnect: boolean;
@@ -120,8 +128,8 @@ export declare class HocuspocusProvider extends EventEmitter {
         resolve: (value?: any) => void;
         reject: (reason?: any) => void;
     } | null;
-    constructor(options?: Partial<HocuspocusProviderOptions>);
-    setOptions(options?: Partial<HocuspocusProviderOptions>): void;
+    constructor(configuration: HocuspocusProviderConfiguration);
+    setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
     connect(): Promise<void>;
     createWebSocketConnection(): Promise<unknown>;
     resolveConnectionAttempt(): void;
@@ -130,7 +138,7 @@ export declare class HocuspocusProvider extends EventEmitter {
     get awareness(): Awareness;
     checkConnection(): void;
     forceSync(): void;
-    registerBeforeUnloadEventListener(): void;
+    registerEventListeners(): void;
     documentUpdateHandler(update: Uint8Array, origin: any): void;
     awarenessUpdateHandler({ added, updated, removed }: any, origin: any): void;
     permissionDeniedHandler(reason: string): void;

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

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

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

@@ -32,3 +32,13 @@ export interface Constructable<T> {
     new (...args: any): T;
 }
 export declare type ConstructableOutgoingMessage = Constructable<AuthenticationMessage> | Constructable<AwarenessMessage> | Constructable<QueryAwarenessMessage> | Constructable<SyncStepOneMessage> | Constructable<SyncStepTwoMessage> | Constructable<UpdateMessage>;
+export declare type onAwarenessUpdateParameters = {
+    states: StatesArray;
+};
+export declare type onAwarenessChangeParameters = {
+    states: StatesArray;
+};
+export declare type StatesArray = {
+    clientId: number;
+    [key: string | number]: any;
+}[];

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

@@ -2,10 +2,10 @@
 import AsyncLock from 'async-lock';
 import WebSocket from 'ws';
 import { IncomingMessage as HTTPIncomingMessage } from 'http';
+import { CloseEvent } from '@hocuspocus/common';
 import Document from './Document';
-import { CloseEvent } from './types';
-import { MessageLogger } from './Debugger';
-declare class Connection {
+import { Debugger } from './Debugger';
+export declare class Connection {
     webSocket: WebSocket;
     context: any;
     document: Document;
@@ -17,11 +17,11 @@ declare class Connection {
     socketId: string;
     lock: AsyncLock;
     readOnly: Boolean;
-    debugger: MessageLogger;
+    logger: Debugger;
     /**
      * Constructor.
      */
-    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly?: boolean);
+    constructor(connection: WebSocket, request: HTTPIncomingMessage, document: Document, timeout: number, socketId: string, context: any, readOnly: boolean | undefined, logger: Debugger);
     /**
      * Set a callback that will be triggered when the connection is closed
      */

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

@@ -1,4 +1,4 @@
-export declare class MessageLogger {
+export declare class Debugger {
     logs: any[];
     listen: boolean;
     output: boolean;
@@ -12,4 +12,3 @@ export declare class MessageLogger {
         logs: any[];
     };
 }
-export declare const Debugger: MessageLogger;

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

@@ -3,20 +3,23 @@ import { Awareness } from 'y-protocols/awareness';
 import { Doc } from 'yjs';
 import { mutex } from 'lib0/mutex.js';
 import Connection from './Connection';
-import { MessageLogger } from './Debugger';
-declare class Document extends Doc {
+import { Debugger } from './Debugger';
+export declare class Document extends Doc {
     awareness: Awareness;
     callbacks: {
         onUpdate: (document: Document, connection: Connection, update: Uint8Array) => void;
     };
-    connections: Map<any, any>;
+    connections: Map<WebSocket, {
+        clients: Set<any>;
+        connection: Connection;
+    }>;
     name: string;
     mux: mutex;
-    debugger: MessageLogger;
+    logger: Debugger;
     /**
      * Constructor.
      */
-    constructor(name: string);
+    constructor(name: string, logger: Debugger);
     /**
      * Check if the Document is empty
      */

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

@@ -1,13 +1,16 @@
 /// <reference types="node" />
-import WebSocket, { WebSocketServer } from 'ws';
+import WebSocket, { AddressInfo, WebSocketServer } from 'ws';
 import { IncomingMessage, Server as HTTPServer } from 'http';
 import { Configuration, Hook } from './types';
-import { MessageLogger } from './Debugger';
+import Document from './Document';
+import { Debugger } from './Debugger';
 import { onListenPayload } from '.';
 export declare const defaultConfiguration: {
     name: null;
     port: number;
     timeout: number;
+    debounce: number;
+    maxDebounce: number;
     quiet: boolean;
 };
 /**
@@ -15,19 +18,24 @@ export declare const defaultConfiguration: {
  */
 export declare class Hocuspocus {
     configuration: Configuration;
-    documents: Map<any, any>;
+    documents: Map<string, Document>;
     httpServer?: HTTPServer;
     webSocketServer?: WebSocketServer;
-    debugger: MessageLogger;
+    debugger: Debugger;
+    constructor(configuration?: Partial<Configuration>);
     /**
      * Configure the server
      */
     configure(configuration: Partial<Configuration>): Hocuspocus;
-    get authenticationRequired(): boolean;
+    get requiresAuthentication(): boolean;
     /**
      * Start the server
      */
-    listen(portOrCallback?: number | ((data: onListenPayload) => Promise<any>) | null, callback?: any): Promise<void>;
+    listen(portOrCallback?: number | ((data: onListenPayload) => Promise<any>) | null, callback?: any): Promise<Hocuspocus>;
+    get address(): AddressInfo;
+    get URL(): string;
+    get webSocketURL(): string;
+    get httpURL(): string;
     private showStartScreen;
     /**
      * Get the total number of active documents
@@ -46,37 +54,47 @@ export declare class Hocuspocus {
      */
     destroy(): Promise<any>;
     /**
-     * Handle the incoming WebSocket connection
+     * The `handleConnection` method 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.
      */
     handleConnection(incoming: WebSocket, request: IncomingMessage, documentName: string, context?: any): void;
     /**
      * Handle update of the given document
-     * @private
      */
     private handleDocumentUpdate;
+    timers: Map<string, {
+        timeout: NodeJS.Timeout;
+        start: number;
+    }>;
+    /**
+     * debounce the given function, using the given identifier
+     */
+    debounce(id: string, func: Function, immediately?: boolean): void;
     /**
      * Create a new document by the given request
-     * @private
      */
     private createDocument;
     /**
      * Create a new connection by the given request and document
-     * @private
      */
     private createConnection;
     /**
-     * Run the given hook on all configured extensions
-     * Runs the given callback after each hook
+     * 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>;
     /**
      * Get parameters by the given request
-     * @private
      */
     private static getParameters;
     /**
      * Get document name by the given request
-     * @private
      */
     private getDocumentNameFromRequest;
     enableDebugging(): void;

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

@@ -1,10 +1,13 @@
+import { Awareness } from 'y-protocols/awareness';
 import Connection from './Connection';
 import { IncomingMessage } from './IncomingMessage';
-import { MessageLogger } from './Debugger';
+import { Debugger } from './Debugger';
+import Document from './Document';
 export declare class MessageReceiver {
     message: IncomingMessage;
-    debugger: MessageLogger;
-    constructor(message: IncomingMessage);
-    apply(connection: Connection): void;
-    readSyncMessage(message: IncomingMessage, connection: Connection): 0 | 1 | 2;
+    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;
+    applyQueryAwarenessMessage(awareness: Awareness, reply?: (message: Uint8Array) => void): void;
 }

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

@@ -8,6 +8,7 @@ export declare class OutgoingMessage {
     constructor();
     createSyncMessage(): OutgoingMessage;
     createAwarenessUpdateMessage(awareness: Awareness, changedClients?: Array<any>): OutgoingMessage;
+    writeQueryAwareness(): OutgoingMessage;
     writeAuthenticated(): OutgoingMessage;
     writePermissionDenied(reason: string): OutgoingMessage;
     writeFirstSyncStepFor(document: Document): OutgoingMessage;

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

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