@jupyter/docprovider 4.2.0 → 4.3.0-alpha.0

package/lib/TimelineSlider.d.ts

@@ -1,12 +1,14 @@
 import { ReactWidget } from '@jupyterlab/apputils';
 import { IForkProvider } from './ydrive';
+import { ServerConnection } from '@jupyterlab/services';
 export declare class TimelineWidget extends ReactWidget {
     private apiURL;
     private provider;
     private contentType;
     private format;
     private documentTimelineUrl;
-    constructor(apiURL: string, provider: IForkProvider, contentType: string, format: string, documentTimelineUrl: string);
+    private _serverSettings?;
+    constructor(apiURL: string, provider: IForkProvider, contentType: string, format: string, documentTimelineUrl: string, serverSettings?: ServerConnection.ISettings);
     render(): JSX.Element;
     updateContent(apiURL: string, provider: IForkProvider): void;
 }

package/lib/TimelineSlider.js

@@ -6,17 +6,18 @@ import { ReactWidget } from '@jupyterlab/apputils';
 import { TimelineSliderComponent } from './component';
 import * as React from 'react';
 export class TimelineWidget extends ReactWidget {
-    constructor(apiURL, provider, contentType, format, documentTimelineUrl) {
+    constructor(apiURL, provider, contentType, format, documentTimelineUrl, serverSettings) {
         super();
         this.apiURL = apiURL;
         this.provider = provider;
         this.contentType = contentType;
         this.format = format;
         this.documentTimelineUrl = documentTimelineUrl;
+        this._serverSettings = serverSettings;
         this.addClass('jp-timelineSliderWrapper');
     }
     render() {
-        return (React.createElement(TimelineSliderComponent, { key: this.apiURL, apiURL: this.apiURL, provider: this.provider, contentType: this.contentType, format: this.format, documentTimelineUrl: this.documentTimelineUrl }));
+        return (React.createElement(TimelineSliderComponent, { key: this.apiURL, apiURL: this.apiURL, provider: this.provider, contentType: this.contentType, format: this.format, documentTimelineUrl: this.documentTimelineUrl, serverSettings: this._serverSettings }));
     }
     updateContent(apiURL, provider) {
         this.apiURL = apiURL;

package/lib/component.d.ts

@@ -1,12 +1,14 @@
 import React from 'react';
 import '../style/slider.css';
 import { IForkProvider } from './ydrive';
+import { ServerConnection } from '@jupyterlab/services';
 type Props = {
     apiURL: string;
     provider: IForkProvider;
     contentType: string;
     format: string;
     documentTimelineUrl: string;
+    serverSettings?: ServerConnection.ISettings;
 };
 export declare const TimelineSliderComponent: React.FC<Props>;
 export {};

package/lib/component.js

@@ -7,7 +7,7 @@ import '../style/slider.css';
 import { requestUndoRedo, requestDocSession, requestDocumentTimeline } from './requests';
 import { historyIcon } from '@jupyterlab/ui-components';
 import { Notification } from '@jupyterlab/apputils';
-export const TimelineSliderComponent = ({ apiURL, provider, contentType, format, documentTimelineUrl }) => {
+export const TimelineSliderComponent = ({ apiURL, provider, contentType, format, documentTimelineUrl, serverSettings }) => {
     const [data, setData] = useState({
         roomId: '',
         timestamps: [],
@@ -23,7 +23,7 @@ export const TimelineSliderComponent = ({ apiURL, provider, contentType, format,
     async function fetchTimeline(notebookPath) {
         try {
             if (isFirstChange.current) {
-                const response = await requestDocumentTimeline(format, contentType, notebookPath);
+                const response = await requestDocumentTimeline(format, contentType, notebookPath, serverSettings);
                 if (!response.ok) {
                     if (response.status === 404) {
                         throw new Error('Not found');
@@ -43,7 +43,7 @@ export const TimelineSliderComponent = ({ apiURL, provider, contentType, format,
                     setData(data);
                     setCurrentTimestampIndex(data.timestamps.length - 1);
                     provider.connectToForkDoc(data.forkRoom, data.sessionId);
-                    sessionRef.current = await requestDocSession(format, contentType, extractFilenameFromURL(apiURL));
+                    sessionRef.current = await requestDocSession(format, contentType, extractFilenameFromURL(apiURL), serverSettings);
                 }
                 setToggle(true);
                 isFirstChange.current = false;
@@ -59,7 +59,7 @@ export const TimelineSliderComponent = ({ apiURL, provider, contentType, format,
             console.error('Session is not initialized');
             return;
         }
-        const response = await requestUndoRedo(`${sessionRef.current.format}:${sessionRef.current.type}:${sessionRef.current.fileId}`, 'restore', 0, data.forkRoom);
+        const response = await requestUndoRedo(`${sessionRef.current.format}:${sessionRef.current.type}:${sessionRef.current.fileId}`, 'restore', 0, data.forkRoom, serverSettings);
         if (response.code === 200) {
             Notification.success(response.status, { autoClose: 4000 });
             provider.reconnect();
@@ -84,7 +84,7 @@ export const TimelineSliderComponent = ({ apiURL, provider, contentType, format,
                 console.error('Session is not initialized');
                 return;
             }
-            await requestUndoRedo(`${sessionRef.current.format}:${sessionRef.current.type}:${sessionRef.current.fileId}`, action, steps, data.forkRoom);
+            await requestUndoRedo(`${sessionRef.current.format}:${sessionRef.current.type}:${sessionRef.current.fileId}`, action, steps, data.forkRoom, serverSettings);
         }
         catch (error) {
             console.error('Error fetching or applying updates:', error);

package/lib/forkManager.d.ts

@@ -1,5 +1,5 @@
 import { ICollaborativeContentProvider } from '@jupyter/collaborative-drive';
-import { Event } from '@jupyterlab/services';
+import { Event, ServerConnection } from '@jupyterlab/services';
 import { ISignal } from '@lumino/signaling';
 import { IAllForksResponse, IForkChangedEvent, IForkCreationResponse, IForkManager } from './tokens';
 import { IForkProvider } from './ydrive';
@@ -32,10 +32,12 @@ export declare class ForkManager implements IForkManager {
     private _eventManager;
     private _forkAddedSignal;
     private _forkDeletedSignal;
+    private _serverSettings?;
 }
 export declare namespace ForkManager {
     interface IOptions {
         contentProvider: ICollaborativeContentProvider;
         eventManager: Event.IManager;
+        serverSettings?: ServerConnection.ISettings;
     }
 }

package/lib/forkManager.js

@@ -15,6 +15,7 @@ export class ForkManager {
         this._contentProvider = contentProvider;
         this._eventManager = eventManager;
         this._eventManager.stream.connect(this._handleEvent, this);
+        this._serverSettings = options.serverSettings;
     }
     get isDisposed() {
         return this._disposed;
@@ -40,13 +41,13 @@ export class ForkManager {
             body: JSON.stringify({ title, description, synchronize })
         };
         const url = URLExt.join(ROOM_FORK_URL, rootId);
-        const response = await requestAPI(url, init);
+        const response = await requestAPI(url, init, this._serverSettings);
         return response;
     }
     async getAllForks(rootId) {
         const url = URLExt.join(ROOM_FORK_URL, rootId);
         const init = { method: 'GET' };
-        const response = await requestAPI(url, init);
+        const response = await requestAPI(url, init, this._serverSettings);
         return response;
     }
     async deleteFork(options) {
@@ -54,7 +55,7 @@ export class ForkManager {
         const url = URLExt.join(ROOM_FORK_URL, forkId);
         const query = URLExt.objectToQueryString({ merge });
         const init = { method: 'DELETE' };
-        await requestAPI(`${url}${query}`, init);
+        await requestAPI(`${url}${query}`, init, this._serverSettings);
     }
     getProvider(options) {
         const { documentPath, format, type } = options;

package/lib/requests.d.ts

@@ -1,4 +1,4 @@
-import { Contents } from '@jupyterlab/services';
+import { ServerConnection, Contents } from '@jupyterlab/services';
 export declare const ROOM_FORK_URL = "api/collaboration/fork";
 /**
  * Document session model
@@ -28,7 +28,7 @@ export interface ISessionModel {
  * @param init Initial values for the request
  * @returns The response body interpreted as JSON
  */
-export declare function requestAPI<T = any>(endPoint?: string, init?: RequestInit): Promise<T>;
-export declare function requestDocSession(format: string, type: string, path: string): Promise<ISessionModel>;
-export declare function requestDocumentTimeline(format: string, type: string, path: string): Promise<any>;
-export declare function requestUndoRedo(roomid: string, action: 'undo' | 'redo' | 'restore', steps: number, forkRoom: string): Promise<any>;
+export declare function requestAPI<T = any>(endPoint?: string, init?: RequestInit, serverSettings?: ServerConnection.ISettings): Promise<T>;
+export declare function requestDocSession(format: string, type: string, path: string, serverSettings?: ServerConnection.ISettings): Promise<ISessionModel>;
+export declare function requestDocumentTimeline(format: string, type: string, path: string, serverSettings?: ServerConnection.ISettings): Promise<any>;
+export declare function requestUndoRedo(roomid: string, action: 'undo' | 'redo' | 'restore', steps: number, forkRoom: string, serverSettings?: ServerConnection.ISettings): Promise<any>;

package/lib/requests.js

@@ -19,9 +19,9 @@ export const ROOM_FORK_URL = 'api/collaboration/fork';
  * @param init Initial values for the request
  * @returns The response body interpreted as JSON
  */
-export async function requestAPI(endPoint = '', init = {}) {
+export async function requestAPI(endPoint = '', init = {}, serverSettings) {
     // Make request to Jupyter API
-    const settings = ServerConnection.makeSettings();
+    const settings = serverSettings !== null && serverSettings !== void 0 ? serverSettings : ServerConnection.makeSettings();
     const requestUrl = URLExt.join(settings.baseUrl, endPoint);
     let response;
     try {
@@ -44,8 +44,8 @@ export async function requestAPI(endPoint = '', init = {}) {
     }
     return data;
 }
-export async function requestDocSession(format, type, path) {
-    const settings = ServerConnection.makeSettings();
+export async function requestDocSession(format, type, path, serverSettings) {
+    const settings = serverSettings !== null && serverSettings !== void 0 ? serverSettings : ServerConnection.makeSettings();
     const url = URLExt.join(settings.baseUrl, DOC_SESSION_URL, encodeURIComponent(path));
     const body = {
         method: 'PUT',
@@ -72,8 +72,8 @@ export async function requestDocSession(format, type, path) {
     }
     return data;
 }
-export async function requestDocumentTimeline(format, type, path) {
-    const settings = ServerConnection.makeSettings();
+export async function requestDocumentTimeline(format, type, path, serverSettings) {
+    const settings = serverSettings !== null && serverSettings !== void 0 ? serverSettings : ServerConnection.makeSettings();
     let url = URLExt.join(settings.baseUrl, TIMELINE_URL, path);
     url = url.concat(`?format=${format}&&type=${type}`);
     const body = {
@@ -88,8 +88,8 @@ export async function requestDocumentTimeline(format, type, path) {
     }
     return response;
 }
-export async function requestUndoRedo(roomid, action, steps, forkRoom) {
-    const settings = ServerConnection.makeSettings();
+export async function requestUndoRedo(roomid, action, steps, forkRoom, serverSettings) {
+    const settings = serverSettings !== null && serverSettings !== void 0 ? serverSettings : ServerConnection.makeSettings();
     let url = URLExt.join(settings.baseUrl, DOC_FORK_URL, encodeURIComponent(roomid));
     url = url.concat(`?action=${action}&&steps=${steps}&&forkRoom=${forkRoom}`);
     const body = { method: 'PUT' };

package/lib/tokens.d.ts

@@ -101,3 +101,9 @@ export interface IForkManager extends IDisposable {
  * Token providing a fork manager instance.
  */
 export declare const IForkManagerToken: Token<IForkManager>;
+export interface ISessionClosePayload {
+    reason: 'unknown_session' | 'version_mismatch' | 'initialization_error';
+    sessionId?: string;
+    reloadable?: boolean;
+    errorReason?: string;
+}

package/lib/ydrive.js

@@ -1,6 +1,6 @@
 // Copyright (c) Jupyter Development Team.
 // Distributed under the terms of the Modified BSD License.
-import { PageConfig, URLExt } from '@jupyterlab/coreutils';
+import { PageConfig } from '@jupyterlab/coreutils';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
 import { WebSocketProvider } from './yprovider';
@@ -8,10 +8,6 @@ import * as decoding from 'lib0/decoding';
 import * as encoding from 'lib0/encoding';
 const DISABLE_RTC = PageConfig.getOption('disableRTC') === 'true' ? true : false;
 const RAW_MESSAGE_TYPE = 2;
-/**
- * The url for the default drive service.
- */
-const DOCUMENT_PROVIDER_URL = 'api/collaboration/room';
 export class RtcContentProvider {
     constructor(options) {
         this._onCreate = (options, sharedModel) => {
@@ -30,13 +26,13 @@ export class RtcContentProvider {
             });
             try {
                 const provider = new WebSocketProvider({
-                    url: URLExt.join(this._serverSettings.wsUrl, DOCUMENT_PROVIDER_URL),
                     path: options.path,
                     format: options.format,
                     contentType: options.contentType,
                     model: sharedModel,
                     user: this._user,
-                    translator: this._trans
+                    translator: this._trans,
+                    serverSettings: this._serverSettings
                 });
                 // Add the document path in the list of opened ones for this user.
                 const state = ((_e = this._globalAwareness) === null || _e === void 0 ? void 0 : _e.getLocalState()) || {};
@@ -195,6 +191,13 @@ export class RtcContentProvider {
             const key = `${options.format}:${options.type}:${localPath}`;
             const provider = this._providers.get(key);
             if (provider) {
+                // The default jupyter-server REST content provider would ask
+                // for content here; this would trigger any encoding errors
+                // leading to fast-rejection. However we do not ask for
+                // content as it is synced over a websocket instead,
+                // this means that the errors do not propagate.
+                // Instead we handle it by ensuring that the `ready` promise
+                // rejection (due to websocket closure ahead of sync) propagates.
                 // If the document doesn't exist, `super.get` will reject with an
                 // error and the provider will never be resolved.
                 // Use `Promise.all` to reject as soon as possible. The Context will

package/lib/yprovider.d.ts

@@ -1,5 +1,5 @@
 import { IDocumentProvider } from '@jupyter/collaborative-drive';
-import { User } from '@jupyterlab/services';
+import { ServerConnection, User } from '@jupyterlab/services';
 import { TranslationBundle } from '@jupyterlab/translation';
 import { DocumentChange, YDocument } from '@jupyter/ydoc';
 import { WebsocketProvider as YWebsocketProvider } from 'y-websocket';
@@ -32,23 +32,28 @@ export declare class WebSocketProvider implements IDocumentProvider, IForkProvid
      */
     dispose(): void;
     reconnect(): Promise<void>;
+    private get _serverUrl();
     private _connect;
     connectToForkDoc(forkRoomId: string, sessionId: string): Promise<void>;
     get wsProvider(): YWebsocketProvider | null;
     private _disconnect;
     private _onUserChanged;
+    private _buildSessionExpiredMessage;
     private _onConnectionClosed;
     private _onSync;
+    private _getCloseReasonMessage;
     private _awareness;
     private _contentType;
     private _format;
     private _isDisposed;
     private _path;
     private _ready;
-    private _serverUrl;
+    private _customServerUrl?;
     private _sharedModel;
     private _yWebsocketProvider;
+    private _serverSettings;
     private _trans;
+    private _hasSynced;
 }
 /**
  * A namespace for WebSocketProvider statics.
@@ -61,7 +66,7 @@ export declare namespace WebSocketProvider {
         /**
          * The server URL
          */
-        url: string;
+        url?: string;
         /**
          * The document file path
          */
@@ -86,5 +91,9 @@ export declare namespace WebSocketProvider {
          * The jupyterlab translator
          */
         translator: TranslationBundle;
+        /**
+         * The server settings.
+         */
+        serverSettings?: ServerConnection.ISettings;
     }
 }

package/lib/yprovider.js

@@ -2,11 +2,17 @@
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
-import { showErrorMessage, Dialog } from '@jupyterlab/apputils';
+import { Dialog, showDialog } from '@jupyterlab/apputils';
+import { ServerConnection } from '@jupyterlab/services';
 import { PromiseDelegate } from '@lumino/coreutils';
 import { Signal } from '@lumino/signaling';
 import { WebsocketProvider as YWebsocketProvider } from 'y-websocket';
 import { requestDocSession } from './requests';
+import { URLExt } from '@jupyterlab/coreutils';
+/**
+ * The url for the default drive service.
+ */
+const DOCUMENT_PROVIDER_URL = 'api/collaboration/room';
 /**
  * A class to provide Yjs synchronization over WebSocket.
  *
@@ -20,12 +26,47 @@ export class WebSocketProvider {
      * @param options The instantiation options for a WebSocketProvider
      */
     constructor(options) {
-        this._onConnectionClosed = (event) => {
+        var _a;
+        this._onConnectionClosed = async (event) => {
+            if ([4400, 4404, 4500].includes(event.code)) {
+                if (!this._hasSynced) {
+                    // Rejecting the ready promise will close the file placeholder widget.
+                    const reason = this._getCloseReasonMessage(event.code);
+                    this._ready.reject(reason);
+                    // Disposing model prevents repeated websocket reconnection attempts.
+                    // Rejecting the ready promise will ultimately close the file,
+                    // but the document manager takes some time to do so.
+                    this._sharedModel.dispose();
+                }
+            }
             if (event.code === 1003) {
                 console.error('Document provider closed:', event.reason);
-                showErrorMessage(this._trans.__('Document session error'), event.reason, [
-                    Dialog.okButton()
-                ]);
+                let payload;
+                try {
+                    payload = JSON.parse(event.reason);
+                }
+                catch (_a) {
+                    payload = {
+                        reason: 'unknown_session',
+                        sessionId: '',
+                        reloadable: false,
+                        errorReason: event.reason
+                    };
+                }
+                const { title, body } = this._buildSessionExpiredMessage(payload, this._trans);
+                const result = await showDialog({
+                    title,
+                    body,
+                    buttons: payload.reloadable
+                        ? [
+                            Dialog.cancelButton({ label: this._trans.__('Continue') }),
+                            Dialog.okButton({ label: this._trans.__('Reload') })
+                        ]
+                        : [Dialog.okButton({ label: this._trans.__('Ok') })]
+                });
+                if (result.button.accept && payload.reloadable) {
+                    window.location.reload();
+                }
                 // Dispose shared model immediately. Better break the document model,
                 // than overriding data on disk.
                 this._sharedModel.dispose();
@@ -33,6 +74,7 @@ export class WebSocketProvider {
         };
         this._onSync = (isSynced) => {
             if (isSynced) {
+                this._hasSynced = true;
                 if (this._yWebsocketProvider) {
                     this._yWebsocketProvider.off('sync', this._onSync);
                     const state = this._sharedModel.ydoc.getMap('state');
@@ -42,14 +84,17 @@ export class WebSocketProvider {
             }
         };
         this._ready = new PromiseDelegate();
+        this._hasSynced = false;
         this._isDisposed = false;
         this._path = options.path;
         this._contentType = options.contentType;
         this._format = options.format;
-        this._serverUrl = options.url;
+        this._customServerUrl = options.url;
         this._sharedModel = options.model;
         this._awareness = options.model.awareness;
         this._yWebsocketProvider = null;
+        this._serverSettings =
+            (_a = options.serverSettings) !== null && _a !== void 0 ? _a : ServerConnection.makeSettings();
         this._trans = options.translator;
         const user = options.user;
         user.ready
@@ -97,22 +142,38 @@ export class WebSocketProvider {
         this._disconnect();
         this._connect();
     }
+    get _serverUrl() {
+        var _a;
+        return ((_a = this._customServerUrl) !== null && _a !== void 0 ? _a : URLExt.join(this._serverSettings.wsUrl, DOCUMENT_PROVIDER_URL));
+    }
     async _connect() {
-        const session = await requestDocSession(this._format, this._contentType, this._path);
+        const session = await requestDocSession(this._format, this._contentType, this._path, this._serverSettings);
+        const token = this._serverSettings.token;
+        const params = { sessionId: session.sessionId };
+        if (this._serverSettings.appendToken && token !== '') {
+            params['token'] = token;
+        }
         this._yWebsocketProvider = new YWebsocketProvider(this._serverUrl, `${session.format}:${session.type}:${session.fileId}`, this._sharedModel.ydoc, {
             disableBc: true,
-            params: { sessionId: session.sessionId },
-            awareness: this._awareness
+            params,
+            awareness: this._awareness,
+            WebSocketPolyfill: this._serverSettings.WebSocket
         });
         this._yWebsocketProvider.on('sync', this._onSync);
         this._yWebsocketProvider.on('connection-close', this._onConnectionClosed);
     }
     async connectToForkDoc(forkRoomId, sessionId) {
+        const token = this._serverSettings.token;
+        const params = { sessionId };
+        if (this._serverSettings.appendToken && token !== '') {
+            params['token'] = token;
+        }
         this._disconnect();
         this._yWebsocketProvider = new YWebsocketProvider(this._serverUrl, forkRoomId, this._sharedModel.ydoc, {
             disableBc: true,
-            params: { sessionId },
-            awareness: this._awareness
+            params,
+            awareness: this._awareness,
+            WebSocketPolyfill: this._serverSettings.WebSocket
         });
     }
     get wsProvider() {
@@ -128,4 +189,39 @@ export class WebSocketProvider {
     _onUserChanged(user) {
         this._awareness.setLocalStateField('user', user.identity);
     }
+    _buildSessionExpiredMessage(payload, trans) {
+        switch (payload.reason) {
+            case 'version_mismatch':
+                return {
+                    title: trans.__('Collaboration extension updated'),
+                    body: trans.__('Reload the browser tab to load the new version.')
+                };
+            case 'initialization_error':
+                return {
+                    title: trans.__('Document error'),
+                    body: trans.__('Failed to initialize the document. Close this tab and reopen the file.')
+                };
+            case 'unknown_session':
+            default:
+                return {
+                    title: trans.__('Session expired'),
+                    body: payload.errorReason
+                        ? trans.__(payload.errorReason)
+                        : trans.__('Reload the browser tab to continue.')
+                };
+        }
+    }
+    _getCloseReasonMessage(code) {
+        switch (code) {
+            case 4400: {
+                return this._trans.__('Bad request for %1', this._path);
+            }
+            case 4404: {
+                return this._trans.__('Could not find %1', this._path);
+            }
+            case 4500: {
+                return this._trans.__('Internal server error when loading %1', this._path);
+            }
+        }
+    }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jupyter/docprovider",
-  "version": "4.2.0",
+  "version": "4.3.0-alpha.0",
   "description": "JupyterLab - Document Provider",
   "homepage": "https://github.com/jupyterlab/jupyter-collaboration",
   "bugs": {
@@ -41,7 +41,7 @@
     "watch": "tsc -b --watch"
   },
   "dependencies": {
-    "@jupyter/collaborative-drive": "^4.2.0",
+    "@jupyter/collaborative-drive": "^4.3.0-alpha.0",
     "@jupyter/ydoc": "^2.1.3 || ^3.0.0",
     "@jupyterlab/apputils": "^4.5.0",
     "@jupyterlab/cells": "^4.5.0",
@@ -59,6 +59,7 @@
   },
   "devDependencies": {
     "@jupyterlab/testing": "^4.5.0",
+    "@jupyterlab/testutils": "^4.5.0",
     "@types/jest": "^29.2.0",
     "jest": "^29.5.0",
     "rimraf": "^4.1.2",