@hocuspocus/extension-webhook 3.4.4 → 3.4.6-rc.0

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

@@ -1,13 +0,0 @@
-import * as encoding from "lib0/encoding";
-import * as decoding from "lib0/decoding";
-import type { AuthorizedScope } from "../../provider/src";
-export declare enum AuthMessageType {
-    Token = 0,
-    PermissionDenied = 1,
-    Authenticated = 2
-}
-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, scope: AuthorizedScope) => void;
-export declare const writeTokenSyncRequest: (encoder: encoding.Encoder) => void;
-export declare const readAuthMessage: (decoder: decoding.Decoder, sendToken: () => void, permissionDeniedHandler: (reason: string) => void, authenticatedHandler: (scope: string) => void) => void;

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

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

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

@@ -1,4 +0,0 @@
-export * from "./auth.ts";
-export * from "./CloseEvents.ts";
-export * from "./awarenessStatesToArray.ts";
-export * from "./types.ts";

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

@@ -1,10 +0,0 @@
-/**
- * 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
-}

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

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

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

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

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

@@ -1,67 +0,0 @@
-import type { Extension, onChangePayload, onConfigurePayload, onConnectPayload, onLoadDocumentPayload, onDestroyPayload, onDisconnectPayload, onRequestPayload, onUpgradePayload } from "@hocuspocus/server";
-export interface LoggerConfiguration {
-    /**
-     * Prepend all logging message with a string.
-     *
-     * @deprecated
-     */
-    prefix: null | string;
-    /**
-     * Whether to log something for the `onLoadDocument` hook.
-     */
-    onLoadDocument: boolean;
-    /**
-     * 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.
-     */
-    onConnect: boolean;
-    /**
-     * Whether to log something for the `onDisconnect` hook.
-     */
-    onDisconnect: boolean;
-    /**
-     * Whether to log something for the `onUpgrade` hook.
-     */
-    onUpgrade: boolean;
-    /**
-     * Whether to log something for the `onRequest` hook.
-     */
-    onRequest: boolean;
-    /**
-     * Whether to log something for the `onDestroy` hook.
-     */
-    onDestroy: boolean;
-    /**
-     * Whether to log something for the `onConfigure` hook.
-     */
-    onConfigure: boolean;
-    /**
-     * A log function, if none is provided output will go to console
-     */
-    log: (...args: any[]) => void;
-}
-export declare class Logger implements Extension {
-    name: string | null;
-    configuration: LoggerConfiguration;
-    /**
-     * Constructor
-     */
-    constructor(configuration?: Partial<LoggerConfiguration>);
-    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>;
-    onRequest(data: onRequestPayload): Promise<void>;
-    onDestroy(data: onDestroyPayload): Promise<void>;
-    private log;
-}

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

@@ -1 +0,0 @@
-export * from "./Logger.ts";

package/dist/packages/extension-redis/src/Redis.d.ts

@@ -1,124 +0,0 @@
-import type { Extension, Hocuspocus, afterLoadDocumentPayload, afterStoreDocumentPayload, afterUnloadDocumentPayload, beforeBroadcastStatelessPayload, beforeUnloadDocumentPayload, onAwarenessUpdatePayload, onChangePayload, onConfigurePayload, onStoreDocumentPayload } from "@hocuspocus/server";
-import { type ExecutionResult, type Lock, Redlock } from "@sesamecare-oss/redlock";
-import type { Cluster, ClusterNode, ClusterOptions, RedisOptions } from "ioredis";
-import RedisClient from "ioredis";
-export type RedisInstance = RedisClient | Cluster;
-export interface Configuration {
-    /**
-     * Redis port
-     */
-    port: number;
-    /**
-     * Redis host
-     */
-    host: string;
-    /**
-     * Redis Cluster
-     */
-    nodes?: ClusterNode[];
-    /**
-     * Duplicate from an existed Redis instance
-     */
-    redis?: RedisInstance;
-    /**
-     * Redis instance creator
-     */
-    createClient?: () => RedisInstance;
-    /**
-     * Options passed directly to Redis constructor
-     *
-     * https://github.com/luin/ioredis/blob/master/API.md#new-redisport-host-options
-     */
-    options?: ClusterOptions | RedisOptions;
-    /**
-     * An unique instance name, required to filter messages in Redis.
-     * If none is provided an unique id is generated.
-     */
-    identifier: string;
-    /**
-     * Namespace for Redis keys, if none is provided 'hocuspocus' is used
-     */
-    prefix: string;
-    /**
-     * The maximum time for the Redis lock in ms (in case it can’t be released).
-     */
-    lockTimeout: number;
-    /**
-     * A delay before onDisconnect is executed. This allows last minute updates'
-     * sync messages to be received by the subscription before it's closed.
-     */
-    disconnectDelay: number;
-}
-export declare class Redis implements Extension {
-    /**
-     * Make sure to give that extension a higher priority, so
-     * the `onStoreDocument` hook is able to intercept the chain,
-     * before documents are stored to the database.
-     */
-    priority: number;
-    configuration: Configuration;
-    redisTransactionOrigin: string;
-    pub: RedisInstance;
-    sub: RedisInstance;
-    instance: Hocuspocus;
-    redlock: Redlock;
-    locks: Map<string, {
-        lock: Lock;
-        release?: Promise<ExecutionResult>;
-    }>;
-    messagePrefix: Buffer;
-    private pendingAfterStoreDocumentResolves;
-    constructor(configuration: Partial<Configuration>);
-    onConfigure({ instance }: onConfigurePayload): Promise<void>;
-    private getKey;
-    private pubKey;
-    private subKey;
-    private lockKey;
-    private encodeMessage;
-    private decodeMessage;
-    /**
-     * Once a document is loaded, subscribe to the channel in Redis.
-     */
-    afterLoadDocument({ documentName, document, }: afterLoadDocumentPayload): Promise<unknown>;
-    /**
-     * Publish the first sync step through Redis.
-     */
-    private publishFirstSyncStep;
-    /**
-     * Let’s ask Redis who is connected already.
-     */
-    private requestAwarenessFromOtherInstances;
-    /**
-     * Before the document is stored, make sure to set a lock in Redis.
-     * That’s meant to avoid conflicts with other instances trying to store the document.
-     */
-    onStoreDocument({ documentName }: onStoreDocumentPayload): Promise<void>;
-    /**
-     * Release the Redis lock, so other instances can store documents.
-     */
-    afterStoreDocument({ documentName, socketId, }: afterStoreDocumentPayload): Promise<void>;
-    /**
-     * Handle awareness update messages received directly by this Hocuspocus instance.
-     */
-    onAwarenessUpdate({ documentName, awareness, added, updated, removed, document, }: onAwarenessUpdatePayload): Promise<number | undefined>;
-    /**
-     * Handle incoming messages published on subscribed document channels.
-     * Note that this will also include messages from ourselves as it is not possible
-     * in Redis to filter these.
-     */
-    private handleIncomingMessage;
-    /**
-     * if the ydoc changed, we'll need to inform other Hocuspocus servers about it.
-     */
-    onChange(data: onChangePayload): Promise<any>;
-    /**
-     * Delay unloading to allow syncs to finish
-     */
-    beforeUnloadDocument(data: beforeUnloadDocumentPayload): Promise<void>;
-    afterUnloadDocument(data: afterUnloadDocumentPayload): Promise<void>;
-    beforeBroadcastStateless(data: beforeBroadcastStatelessPayload): Promise<number>;
-    /**
-     * Kill the Redlock connection immediately.
-     */
-    onDestroy(): Promise<void>;
-}

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

@@ -1 +0,0 @@
-export * from "./Redis.ts";

package/dist/packages/extension-s3/src/S3.d.ts

@@ -1,44 +0,0 @@
-import type { DatabaseConfiguration } from "@hocuspocus/extension-database";
-import { Database } from "@hocuspocus/extension-database";
-import { S3Client } from "@aws-sdk/client-s3";
-export interface S3Configuration extends DatabaseConfiguration {
-    /**
-     * AWS S3 region
-     */
-    region?: string;
-    /**
-     * S3 bucket name
-     */
-    bucket: string;
-    /**
-     * S3 key prefix for documents (optional)
-     */
-    prefix?: string;
-    /**
-     * AWS credentials
-     */
-    credentials?: {
-        accessKeyId: string;
-        secretAccessKey: string;
-    };
-    /**
-     * S3 endpoint URL (for S3-compatible services like MinIO)
-     */
-    endpoint?: string;
-    /**
-     * Force path style URLs (required for MinIO)
-     */
-    forcePathStyle?: boolean;
-    /**
-     * Custom S3 client
-     */
-    s3Client?: S3Client;
-}
-export declare class S3 extends Database {
-    private s3Client?;
-    configuration: S3Configuration;
-    constructor(configuration: Partial<S3Configuration>);
-    private getObjectKey;
-    onConfigure(): Promise<void>;
-    onListen(): Promise<void>;
-}

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

@@ -1 +0,0 @@
-export * from "./S3.ts";

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

@@ -1,27 +0,0 @@
-import type { DatabaseConfiguration } from "@hocuspocus/extension-database";
-import { Database } 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

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

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

@@ -1,30 +0,0 @@
-import type { Extension, onConnectPayload } from "@hocuspocus/server";
-export interface ThrottleConfiguration {
-    throttle: number | null | false;
-    consideredSeconds: number;
-    banTime: number;
-    cleanupInterval: number;
-}
-export declare class Throttle implements Extension {
-    configuration: ThrottleConfiguration;
-    connectionsByIp: Map<string, Array<number>>;
-    bannedIps: Map<string, number>;
-    cleanupInterval?: NodeJS.Timeout;
-    /**
-     * Constructor
-     */
-    constructor(configuration?: Partial<ThrottleConfiguration>);
-    onDestroy(): Promise<void>;
-    clearMaps(): void;
-    isBanned(ip: string): boolean;
-    /**
-     * Throttle requests
-     * @private
-     */
-    private throttle;
-    /**
-     * onConnect hook
-     * @param data
-     */
-    onConnect(data: onConnectPayload): Promise<any>;
-}

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

@@ -1,56 +0,0 @@
-import type { Extension, onChangePayload, onConnectPayload, onDisconnectPayload, onLoadDocumentPayload } from "@hocuspocus/server";
-import type { Transformer } from "@hocuspocus/transformer";
-import type { Doc } from "yjs";
-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: NodeJS.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<import("axios").AxiosResponse<any, any, {}>>;
-    /**
-     * onChange hook
-     */
-    onChange(data: onChangePayload): Promise<void>;
-    /**
-     * onLoadDocument hook
-     */
-    onLoadDocument(data: onLoadDocumentPayload): Promise<void>;
-    /**
-     * onConnect hook
-     */
-    onConnect(data: onConnectPayload): Promise<any>;
-    onDisconnect(data: onDisconnectPayload): Promise<void>;
-}

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

@@ -1,9 +0,0 @@
-export default class EventEmitter {
-    callbacks: {
-        [key: string]: Function[];
-    };
-    on(event: string, fn: Function): this;
-    protected emit(event: string, ...args: any): this;
-    off(event: string, fn?: Function): this;
-    removeAllListeners(): void;
-}

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

@@ -1,116 +0,0 @@
-import type { Event, MessageEvent } from "ws";
-import { Awareness } from "y-protocols/awareness";
-import * as Y from "yjs";
-import EventEmitter from "./EventEmitter.ts";
-import type { CompleteHocuspocusProviderWebsocketConfiguration } from "./HocuspocusProviderWebsocket.ts";
-import { HocuspocusProviderWebsocket } from "./HocuspocusProviderWebsocket.ts";
-import type { AuthorizedScope, ConstructableOutgoingMessage, onAuthenticatedParameters, onAuthenticationFailedParameters, onAwarenessChangeParameters, onAwarenessUpdateParameters, onCloseParameters, onDisconnectParameters, onMessageParameters, onOpenParameters, onOutgoingMessageParameters, onStatelessParameters, onStatusParameters, onSyncedParameters, onUnsyncedChangesParameters } from "./types.ts";
-export type HocuspocusProviderConfiguration = Required<Pick<CompleteHocuspocusProviderConfiguration, "name">> & Partial<CompleteHocuspocusProviderConfiguration> & ((Required<Pick<CompleteHocuspocusProviderWebsocketConfiguration, "url">> & Partial<Pick<CompleteHocuspocusProviderWebsocketConfiguration, "preserveTrailingSlash">>) | Required<Pick<CompleteHocuspocusProviderConfiguration, "websocketProvider">>);
-export interface CompleteHocuspocusProviderConfiguration {
-    /**
-     * The identifier/name of your document
-     */
-    name: string;
-    /**
-     * The actual Y.js document
-     */
-    document: Y.Doc;
-    /**
-     * An Awareness instance to keep the presence state of all clients.
-     *
-     * You can disable sharing awareness information by passing `null`.
-     * Note that having no awareness information shared across all connections will break our ping checks
-     * and thus trigger reconnects. You should always have at least one Provider with enabled awareness per
-     * socket connection, or ensure that the Provider receives messages before running into `HocuspocusProviderWebsocket.messageReconnectTimeout`.
-     */
-    awareness: Awareness | null;
-    /**
-     * A token that’s sent to the backend for authentication purposes.
-     */
-    token: string | (() => string) | (() => Promise<string>) | null;
-    /**
-     * Hocuspocus websocket provider
-     */
-    websocketProvider: HocuspocusProviderWebsocket;
-    /**
-     * Force syncing the document in the defined interval.
-     */
-    forceSyncInterval: false | number;
-    onAuthenticated: (data: onAuthenticatedParameters) => void;
-    onAuthenticationFailed: (data: onAuthenticationFailedParameters) => void;
-    onOpen: (data: onOpenParameters) => void;
-    onConnect: () => void;
-    onStatus: (data: onStatusParameters) => void;
-    onMessage: (data: onMessageParameters) => void;
-    onOutgoingMessage: (data: onOutgoingMessageParameters) => void;
-    onSynced: (data: onSyncedParameters) => void;
-    onDisconnect: (data: onDisconnectParameters) => void;
-    onClose: (data: onCloseParameters) => void;
-    onDestroy: () => void;
-    onAwarenessUpdate: (data: onAwarenessUpdateParameters) => void;
-    onAwarenessChange: (data: onAwarenessChangeParameters) => void;
-    onStateless: (data: onStatelessParameters) => void;
-    onUnsyncedChanges: (data: onUnsyncedChangesParameters) => void;
-}
-export declare class AwarenessError extends Error {
-    code: number;
-}
-export declare class HocuspocusProvider extends EventEmitter {
-    configuration: CompleteHocuspocusProviderConfiguration;
-    isSynced: boolean;
-    unsyncedChanges: number;
-    isAuthenticated: boolean;
-    authorizedScope: AuthorizedScope | undefined;
-    manageSocket: boolean;
-    private _isAttached;
-    intervals: any;
-    constructor(configuration: HocuspocusProviderConfiguration);
-    boundDocumentUpdateHandler: (update: Uint8Array, origin: any) => void;
-    boundAwarenessUpdateHandler: ({ added, updated, removed }: any, origin: any) => void;
-    boundPageHide: () => void;
-    boundOnOpen: (event: Event) => Promise<void>;
-    boundOnClose: () => void;
-    forwardConnect: () => this;
-    forwardStatus: (e: onStatusParameters) => this;
-    forwardClose: (e: onCloseParameters) => this;
-    forwardDisconnect: (e: onDisconnectParameters) => this;
-    forwardDestroy: () => this;
-    setConfiguration(configuration?: Partial<HocuspocusProviderConfiguration>): void;
-    get document(): Y.Doc;
-    get isAttached(): boolean;
-    get awareness(): Awareness | null;
-    get hasUnsyncedChanges(): boolean;
-    private resetUnsyncedChanges;
-    incrementUnsyncedChanges(): void;
-    decrementUnsyncedChanges(): void;
-    forceSync(): void;
-    pageHide(): void;
-    registerEventListeners(): void;
-    sendStateless(payload: string): void;
-    sendToken(): Promise<void>;
-    documentUpdateHandler(update: Uint8Array, origin: any): void;
-    awarenessUpdateHandler({ added, updated, removed }: any, origin: any): void;
-    /**
-     * Indicates whether a first handshake with the server has been established
-     *
-     * Note: this does not mean all updates from the client have been persisted to the backend. For this,
-     * use `hasUnsyncedChanges`.
-     */
-    get synced(): boolean;
-    set synced(state: boolean);
-    receiveStateless(payload: string): void;
-    connect(): Promise<unknown>;
-    disconnect(): void;
-    onOpen(event: Event): Promise<void>;
-    getToken(): Promise<string | null>;
-    startSync(): void;
-    send(message: ConstructableOutgoingMessage, args: any): void;
-    onMessage(event: MessageEvent): void;
-    onClose(): void;
-    destroy(): void;
-    detach(): void;
-    attach(): void;
-    permissionDeniedHandler(reason: string): void;
-    authenticatedHandler(scope: string): void;
-    setAwarenessField(key: string, value: any): void;
-}