@hocuspocus/extension-sqlite 1.1.0 → 2.0.0-alpha.0

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import { IncomingMessage, ServerResponse } from 'http';
-import WebSocket, { WebSocketServer } from 'ws';
 import { Socket } from 'net';
+import WebSocket, { WebSocketServer } from 'ws';
 import { Storage } from './Storage';
 export interface Configuration {
     password: string | undefined;

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

@@ -1,6 +1,6 @@
 /// <reference types="node" />
-import { Extension, onChangePayload, onConfigurePayload, onLoadDocumentPayload, onDisconnectPayload, onRequestPayload, onUpgradePayload, connectedPayload } from '@hocuspocus/server';
 import { IncomingMessage, ServerResponse } from 'http';
+import { Extension, onChangePayload, onConfigurePayload, onLoadDocumentPayload, onDisconnectPayload, onRequestPayload, onUpgradePayload, connectedPayload } from '@hocuspocus/server';
 import WebSocket from 'ws';
 import { Storage } from './Storage';
 import { Dashboard } from './Dashboard';

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

@@ -1,5 +1,6 @@
 import { HocuspocusProvider, HocuspocusProviderConfiguration } from './HocuspocusProvider';
-export declare type HocuspocusCloudProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & AdditionalHocuspocusCloudProviderConfiguration;
+import { HocuspocusProviderWebsocketConfiguration } from './HocuspocusProviderWebsocket';
+export declare type HocuspocusCloudProviderConfiguration = Required<Pick<HocuspocusProviderConfiguration, 'name'>> & Partial<HocuspocusProviderConfiguration> & Partial<Pick<HocuspocusProviderWebsocketConfiguration, 'url'>> & AdditionalHocuspocusCloudProviderConfiguration;
 export interface AdditionalHocuspocusCloudProviderConfiguration {
     /**
      * A Hocuspocus Cloud key, get one here: https://hocuspocus.cloud/

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

@@ -1,16 +1,13 @@
 import * as Y from 'yjs';
 import { Awareness } from 'y-protocols/awareness';
 import * as mutex from 'lib0/mutex';
-import type { Event, CloseEvent, MessageEvent } from 'ws';
+import type { CloseEvent, Event, MessageEvent } from 'ws';
 import EventEmitter from './EventEmitter';
 import { ConstructableOutgoingMessage, onAuthenticationFailedParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onStatusParameters, onSyncedParameters, WebSocketStatus } from './types';
+import { HocuspocusProviderWebsocket } from './HocuspocusProviderWebsocket';
 import { onAwarenessChangeParameters, onAwarenessUpdateParameters } from '.';
-export declare type HocuspocusProviderConfiguration = Required<Pick<CompleteHocuspocusProviderConfiguration, 'url' | 'name'>> & Partial<CompleteHocuspocusProviderConfiguration>;
+export declare type HocuspocusProviderConfiguration = Required<Pick<CompleteHocuspocusProviderConfiguration, 'name' | 'websocketProvider'>> & Partial<CompleteHocuspocusProviderConfiguration>;
 export interface CompleteHocuspocusProviderConfiguration {
-    /**
-     * URL of your @hocuspocus/server instance
-     */
-    url: string;
     /**
      * The identifier/name of your document
      */
@@ -19,10 +16,6 @@ export interface CompleteHocuspocusProviderConfiguration {
      * The actual Y.js document
      */
     document: Y.Doc;
-    /**
-     * Pass `false` to start the connection manually.
-     */
-    connect: boolean;
     /**
      * Pass false to disable broadcasting between browser tabs.
      */
@@ -42,49 +35,13 @@ export interface CompleteHocuspocusProviderConfiguration {
         [key: string]: any;
     };
     /**
-     * An optional WebSocket polyfill, for example for Node.js
+     * Hocuspocus websocket provider
      */
-    WebSocketPolyfill: any;
+    websocketProvider: HocuspocusProviderWebsocket;
     /**
      * Force syncing the document in the defined interval.
      */
     forceSyncInterval: false | number;
-    /**
-     * Disconnect when no message is received for the defined amount of milliseconds.
-     */
-    messageReconnectTimeout: number;
-    /**
-     * The delay between each attempt in milliseconds. You can provide a factor to have the delay grow exponentially.
-     */
-    delay: number;
-    /**
-     * The intialDelay is the amount of time to wait before making the first attempt. This option should typically be 0 since you typically want the first attempt to happen immediately.
-     */
-    initialDelay: number;
-    /**
-     * The factor option is used to grow the delay exponentially.
-     */
-    factor: number;
-    /**
-     * The maximum number of attempts or 0 if there is no limit on number of attempts.
-     */
-    maxAttempts: number;
-    /**
-     * minDelay is used to set a lower bound of delay when jitter is enabled. This property has no effect if jitter is disabled.
-     */
-    minDelay: number;
-    /**
-     * The maxDelay option is used to set an upper bound for the delay when factor is enabled. A value of 0 can be provided if there should be no upper bound when calculating delay.
-     */
-    maxDelay: number;
-    /**
-     * If jitter is true then the calculated delay will be a random integer value between minDelay and the calculated delay for the current iteration.
-     */
-    jitter: boolean;
-    /**
-     * A timeout in milliseconds. If timeout is non-zero then a timer is set using setTimeout. If the timeout is triggered then future attempts will be aborted.
-     */
-    timeout: number;
     onAuthenticated: () => void;
     onAuthenticationFailed: (data: onAuthenticationFailedParameters) => void;
     onOpen: (data: onOpenParameters) => void;
@@ -107,32 +64,18 @@ export interface CompleteHocuspocusProviderConfiguration {
 export declare class HocuspocusProvider extends EventEmitter {
     configuration: CompleteHocuspocusProviderConfiguration;
     subscribedToBroadcastChannel: boolean;
-    webSocket: WebSocket | null;
-    shouldConnect: boolean;
-    status: WebSocketStatus;
     isSynced: boolean;
     unsyncedChanges: number;
+    status: WebSocketStatus;
     isAuthenticated: boolean;
-    lastMessageReceived: number;
     mux: mutex.mutex;
     intervals: any;
-    connectionAttempt: {
-        resolve: (value?: any) => void;
-        reject: (reason?: any) => void;
-    } | null;
     constructor(configuration: HocuspocusProviderConfiguration);
+    onStatus({ status }: onStatusParameters): void;
     setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
-    boundConnect: () => Promise<unknown>;
-    cancelWebsocketRetry?: () => void;
-    connect(): Promise<unknown>;
-    createWebSocketConnection(): Promise<unknown>;
-    resolveConnectionAttempt(): void;
-    stopConnectionAttempt(): void;
-    rejectConnectionAttempt(): void;
     get document(): Y.Doc;
     get awareness(): Awareness;
     get hasUnsyncedChanges(): boolean;
-    checkConnection(): void;
     forceSync(): void;
     boundBeforeUnload: () => void;
     beforeUnload(): void;
@@ -140,10 +83,6 @@ export declare class HocuspocusProvider extends EventEmitter {
     sendStateless(payload: string): void;
     documentUpdateHandler(update: Uint8Array, origin: any): void;
     awarenessUpdateHandler({ added, updated, removed }: any, origin: any): void;
-    permissionDeniedHandler(reason: string): void;
-    authenticatedHandler(): void;
-    get serverUrl(): string;
-    get url(): string;
     get synced(): boolean;
     set synced(state: boolean);
     receiveStateless(payload: string): void;
@@ -152,10 +91,12 @@ export declare class HocuspocusProvider extends EventEmitter {
     onOpen(event: Event): Promise<void>;
     getToken(): Promise<string | null>;
     startSync(): void;
-    send(Message: ConstructableOutgoingMessage, args: any, broadcast?: boolean): void;
+    send(message: ConstructableOutgoingMessage, args: any, broadcast?: boolean): void;
     onMessage(event: MessageEvent): void;
     onClose(event: CloseEvent): void;
     destroy(): void;
+    permissionDeniedHandler(reason: string): void;
+    authenticatedHandler(): void;
     get broadcastChannel(): string;
     boundBroadcastChannelSubscriber: (data: ArrayBuffer) => void;
     broadcastChannelSubscriber(data: ArrayBuffer): void;

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

@@ -0,0 +1,115 @@
+import * as mutex from 'lib0/mutex';
+import type { MessageEvent } from 'ws';
+import { Event } from 'ws';
+import EventEmitter from './EventEmitter';
+import { onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatusParameters, WebSocketStatus } from './types';
+import { HocuspocusProvider, onAwarenessChangeParameters, onAwarenessUpdateParameters } from '.';
+export declare type HocuspocusProviderWebsocketConfiguration = Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, 'url'>> & Partial<CompleteHocuspocusProviderWebsocketConfiguration>;
+export interface CompleteHocuspocusProviderWebsocketConfiguration {
+    /**
+     * URL of your @hocuspocus/server instance
+     */
+    url: string;
+    /**
+     * Pass `false` to start the connection manually.
+     */
+    connect: boolean;
+    /**
+     * URL parameters that should be added.
+     */
+    parameters: {
+        [key: string]: any;
+    };
+    /**
+     * An optional WebSocket polyfill, for example for Node.js
+     */
+    WebSocketPolyfill: any;
+    /**
+     * Disconnect when no message is received for the defined amount of milliseconds.
+     */
+    messageReconnectTimeout: number;
+    /**
+     * The delay between each attempt in milliseconds. You can provide a factor to have the delay grow exponentially.
+     */
+    delay: number;
+    /**
+     * The intialDelay is the amount of time to wait before making the first attempt. This option should typically be 0 since you typically want the first attempt to happen immediately.
+     */
+    initialDelay: number;
+    /**
+     * The factor option is used to grow the delay exponentially.
+     */
+    factor: number;
+    /**
+     * The maximum number of attempts or 0 if there is no limit on number of attempts.
+     */
+    maxAttempts: number;
+    /**
+     * minDelay is used to set a lower bound of delay when jitter is enabled. This property has no effect if jitter is disabled.
+     */
+    minDelay: number;
+    /**
+     * The maxDelay option is used to set an upper bound for the delay when factor is enabled. A value of 0 can be provided if there should be no upper bound when calculating delay.
+     */
+    maxDelay: number;
+    /**
+     * If jitter is true then the calculated delay will be a random integer value between minDelay and the calculated delay for the current iteration.
+     */
+    jitter: boolean;
+    /**
+     * A timeout in milliseconds. If timeout is non-zero then a timer is set using setTimeout. If the timeout is triggered then future attempts will be aborted.
+     */
+    timeout: number;
+    onOpen: (data: onOpenParameters) => void;
+    onConnect: () => void;
+    onMessage: (data: onMessageParameters) => void;
+    onOutgoingMessage: (data: onOutgoingMessageParameters) => void;
+    onStatus: (data: onStatusParameters) => void;
+    onDisconnect: (data: onDisconnectParameters) => void;
+    onClose: (data: onCloseParameters) => void;
+    onDestroy: () => void;
+    onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void;
+    onAwarenessChange: (data: onAwarenessChangeParameters) => void;
+    /**
+     * Don’t output any warnings.
+     */
+    quiet: boolean;
+}
+export declare class HocuspocusProviderWebsocket extends EventEmitter {
+    configuration: CompleteHocuspocusProviderWebsocketConfiguration;
+    subscribedToBroadcastChannel: boolean;
+    webSocket: WebSocket | null;
+    shouldConnect: boolean;
+    status: WebSocketStatus;
+    lastMessageReceived: number;
+    mux: mutex.mutex;
+    intervals: any;
+    connectionAttempt: {
+        resolve: (value?: any) => void;
+        reject: (reason?: any) => void;
+    } | null;
+    constructor(configuration: HocuspocusProviderWebsocketConfiguration);
+    receivedOnOpenPayload?: Event | undefined;
+    receivedOnStatusPayload?: onStatusParameters | undefined;
+    onOpen(event: Event): Promise<void>;
+    onStatus(data: onStatusParameters): Promise<void>;
+    attach(provider: HocuspocusProvider): void;
+    detach(provider: HocuspocusProvider): void;
+    setConfiguration(configuration?: Partial<HocuspocusProviderWebsocketConfiguration>): void;
+    boundConnect: () => Promise<unknown>;
+    cancelWebsocketRetry?: () => void;
+    connect(): Promise<unknown>;
+    createWebSocketConnection(): Promise<unknown>;
+    onMessage(event: MessageEvent): void;
+    resolveConnectionAttempt(): void;
+    stopConnectionAttempt(): void;
+    rejectConnectionAttempt(): void;
+    checkConnection(): void;
+    registerEventListeners(): void;
+    get serverUrl(): string;
+    get url(): string;
+    disconnect(): void;
+    send(message: any): void;
+    onClose({ event }: onCloseParameters): void;
+    destroy(): void;
+}

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

@@ -7,8 +7,10 @@ export declare class IncomingMessage {
     decoder: Decoder;
     constructor(data: any);
     readVarUint(): MessageType;
+    readVarString(): string;
     readVarUint8Array(): Uint8Array;
     writeVarUint(type: MessageType): void;
+    writeVarString(string: string): void;
     writeVarUint8Array(data: Uint8Array): void;
     length(): number;
 }

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

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

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

@@ -27,6 +27,7 @@ export interface OutgoingMessageInterface {
     type?: MessageType;
 }
 export interface OutgoingMessageArguments {
+    documentName: string;
     token: string;
     document: Y.Doc;
     awareness: Awareness;

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
+import { IncomingMessage as HTTPIncomingMessage } from 'http';
 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 { Debugger } from './Debugger';
@@ -62,15 +62,5 @@ export declare class Connection {
      * @private
      */
     private handleMessage;
-    /**
-     * Get the underlying connection instance
-     * @deprecated
-     */
-    get instance(): WebSocket;
-    /**
-     * Get the underlying connection instance
-     * @deprecated
-     */
-    get connection(): WebSocket;
 }
 export default Connection;

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

@@ -1,10 +1,9 @@
 /// <reference types="node" />
-import WebSocket, { AddressInfo, WebSocketServer } from 'ws';
 import { IncomingMessage, Server as HTTPServer } from 'http';
-import { Configuration, HookName, HookPayload } from './types';
+import WebSocket, { AddressInfo, WebSocketServer } from 'ws';
+import { Configuration, HookName, HookPayload, onListenPayload } from './types';
 import Document from './Document';
 import { Debugger } from './Debugger';
-import { onListenPayload } from '.';
 export declare const defaultConfiguration: {
     name: null;
     port: number;
@@ -68,7 +67,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, documentName: string, context?: any): void;
+    handleConnection(incoming: WebSocket, request: IncomingMessage, context?: any): void;
     /**
      * Handle update of the given document
      */
@@ -98,10 +97,6 @@ export declare class Hocuspocus {
      * Get parameters by the given request
      */
     private static getParameters;
-    /**
-     * Get document name by the given request
-     */
-    private getDocumentNameFromRequest;
     enableDebugging(): void;
     enableMessageLogging(): void;
     disableLogging(): void;

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

@@ -16,5 +16,6 @@ export declare class IncomingMessage {
     readVarString(): string;
     toUint8Array(): Uint8Array;
     writeVarUint(type: MessageType): void;
+    writeVarString(string: string): void;
     get length(): number;
 }

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

@@ -1,4 +1,3 @@
-import { Awareness } from 'y-protocols/awareness';
 import Connection from './Connection';
 import { IncomingMessage } from './IncomingMessage';
 import { Debugger } from './Debugger';
@@ -9,5 +8,5 @@ export declare class MessageReceiver {
     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, requestFirstSync?: boolean): 0 | 2 | 1;
-    applyQueryAwarenessMessage(awareness: Awareness, reply?: (message: Uint8Array) => void): void;
+    applyQueryAwarenessMessage(document: Document, reply?: (message: Uint8Array) => void): void;
 }

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

@@ -5,7 +5,7 @@ export declare class OutgoingMessage {
     encoder: Encoder;
     type?: number;
     category?: string;
-    constructor();
+    constructor(documentName: string);
     createSyncMessage(): OutgoingMessage;
     createSyncReplyMessage(): OutgoingMessage;
     createAwarenessUpdateMessage(awareness: Awareness, changedClients?: Array<any>): OutgoingMessage;

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 './newHocuspocusProviderWebsocket';
 export * from './randomInteger';
 export * from './redisConnectionSettings';
 export * from './removeDirectory';

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

@@ -1,3 +1,3 @@
-import { HocuspocusProvider, HocuspocusProviderConfiguration } from '@hocuspocus/provider';
+import { HocuspocusProvider, HocuspocusProviderConfiguration, HocuspocusProviderWebsocketConfiguration } from '@hocuspocus/provider';
 import { Hocuspocus } from '@hocuspocus/server';
-export declare const newHocuspocusProvider: (server: Hocuspocus, options?: Partial<Omit<HocuspocusProviderConfiguration, 'url'>>) => HocuspocusProvider;
+export declare const newHocuspocusProvider: (server: Hocuspocus, options?: Partial<HocuspocusProviderConfiguration>, websocketOptions?: Partial<HocuspocusProviderWebsocketConfiguration>) => HocuspocusProvider;

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

@@ -0,0 +1,3 @@
+import { HocuspocusProviderWebsocket, HocuspocusProviderWebsocketConfiguration } from '@hocuspocus/provider';
+import { Hocuspocus } from '@hocuspocus/server';
+export declare const newHocuspocusProviderWebsocket: (server: Hocuspocus, options?: Partial<Omit<HocuspocusProviderWebsocketConfiguration, 'url'>>) => HocuspocusProviderWebsocket;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hocuspocus/extension-sqlite",
   "description": "a generic Hocuspocus persistence driver for the sqlite",
-  "version": "1.1.0",
+  "version": "2.0.0-alpha.0",
   "homepage": "https://hocuspocus.dev",
   "keywords": [
     "hocuspocus",
@@ -26,7 +26,7 @@
     "dist"
   ],
   "dependencies": {
-    "@hocuspocus/extension-database": "^1.1.0",
+    "@hocuspocus/extension-database": "^2.0.0-alpha.0",
     "kleur": "^4.1.4",
     "sqlite3": "^5.0.11"
   },

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

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