Add custom API route for .deepnote files

Signed-off-by: Andy Jakubowski <hello@andyjakubowski.com>

Author: andyjakubowski

README.md

@@ -114,12 +114,12 @@ jlpm run watch
 
 The `jlpm` command is JupyterLab's pinned version of
 [yarn](https://yarnpkg.com/) that is installed with JupyterLab. You may use
-`yarn` or `npm` in lieu of `jlpm` below.
+`yarn` or `npm` instead of `jlpm` below.
 
-In a separate terminal, run `jupyter lab` with the `--config` option to register our custom file contents manager for the `.deepnote` extension. The `--debug` option lets you see HTTP requests in the logs, which is helpful for debugging.
+In a separate terminal, run `jupyter lab`. You can add the `--debug` option to see HTTP requests in the logs, which can be helpful for debugging.
 
 ```shell
-jupyter lab --debug --config="$(pwd)/jupyter-config/server-config/jupyter_server_config.json"
+jupyter lab --debug
 ```
 
 You can watch the source directory and run JupyterLab at the same time in different terminals to watch for changes in the extension's source and automatically rebuild the extension.

jupyter-config/server-config/jupyter_server_config.json

@@ -8,7 +8,6 @@
 
     warnings.warn("Importing 'jupyterlab_deepnote' outside a proper installation.")
     __version__ = "dev"
-from jupyterlab_deepnote.contents import DeepnoteContentsManager
 from .handlers import setup_handlers
 
 

jupyterlab_deepnote/__init__.py

@@ -1,24 +1,38 @@
+from datetime import datetime
 import json
 
 from jupyter_server.base.handlers import APIHandler
 from jupyter_server.utils import url_path_join
+from jupyter_core.utils import ensure_async
 import tornado
 
+
 class RouteHandler(APIHandler):
     # The following decorator should be present on all verb methods (head, get, post,
     # patch, put, delete, options) to ensure only authorized user can request the
     # Jupyter server
     @tornado.web.authenticated
-    def get(self):
-        self.finish(json.dumps({
-            "data": "This is /jupyterlab-deepnote/get-example endpoint!"
-        }))
+    async def get(self):
+        path = self.get_query_argument("path")
+        # Use Jupyter Server’s contents_manager, not direct filesystem access.
+        model = await ensure_async(
+            self.contents_manager.get(path, type="file", format="text", content=True)
+        )
+        # Convert datetimes to strings so JSON can handle them
+        for key in ("created", "last_modified"):
+            if isinstance(model.get(key), datetime):
+                model[key] = model[key].isoformat()
+
+        # Return everything, including YAML content
+        result = {"deepnoteFileModel": model}
+
+        self.finish(json.dumps(result))
 
 
 def setup_handlers(web_app):
     host_pattern = ".*$"
 
     base_url = web_app.settings["base_url"]
-    route_pattern = url_path_join(base_url, "jupyterlab-deepnote", "get-example")
+    route_pattern = url_path_join(base_url, "jupyterlab-deepnote", "file")
     handlers = [(route_pattern, RouteHandler)]
     web_app.add_handlers(host_pattern, handlers)

jupyterlab_deepnote/contents.py

@@ -1,59 +1,42 @@
 import { Contents, RestContentProvider } from '@jupyterlab/services';
-import { z } from 'zod';
 import { transformDeepnoteYamlToNotebookContent } from './transform-deepnote-yaml-to-notebook-content';
+import { requestAPI } from './handler';
 
 export const deepnoteContentProviderName = 'deepnote-content-provider';
-
-const deepnoteFileFromServerSchema = z.object({
-  cells: z.array(z.any()), // or refine further with nbformat
-  metadata: z.object({
-    deepnote: z.object({
-      rawYamlString: z.string()
-    })
-  }),
-  nbformat: z.number(),
-  nbformat_minor: z.number()
-});
-
 export class DeepnoteContentProvider extends RestContentProvider {
   async get(
     localPath: string,
     options?: Contents.IFetchOptions
   ): Promise<Contents.IModel> {
-    const model = await super.get(localPath, options);
-    const isDeepnoteFile =
-      localPath.endsWith('.deepnote') && model.type === 'notebook';
+    const isDeepnoteFile = localPath.endsWith('.deepnote');
 
     if (!isDeepnoteFile) {
       // Not a .deepnote file, return as-is
-      return model;
+      const nonDeepnoteModel = await super.get(localPath, options);
+      return nonDeepnoteModel;
     }
 
-    const validatedModelContent = deepnoteFileFromServerSchema.safeParse(
-      model.content
-    );
-
-    if (!validatedModelContent.success) {
-      console.error(
-        'Invalid .deepnote file content:',
-        validatedModelContent.error
-      );
-      // Return an empty notebook instead of throwing an error
-      model.content.cells = [];
-      return model;
-    }
+    // Call custom API route to fetch the Deepnote file content
+    const data = await requestAPI<any>(`file?path=${localPath}`);
+    const modelData = data.deepnoteFileModel;
 
     // Transform the Deepnote YAML to Jupyter notebook content
-    const transformedModelContent =
-      await transformDeepnoteYamlToNotebookContent(
-        validatedModelContent.data.metadata.deepnote.rawYamlString
-      );
+    const notebookContent = await transformDeepnoteYamlToNotebookContent(
+      modelData.content
+    );
 
-    const transformedModel = {
-      ...model,
-      content: transformedModelContent
+    const model: Contents.IModel = {
+      name: modelData.name,
+      path: modelData.path,
+      type: 'notebook',
+      writable: false,
+      created: modelData.created,
+      last_modified: modelData.last_modified,
+      mimetype: 'application/x-ipynb+json',
+      format: 'json',
+      content: notebookContent
     };
 
-    return transformedModel;
+    return model;
   }
 }