refactor(deno): prefix models with Deno and add cattrs hooks

Author: observerw

src/lsp_client/clients/deno/README.md

@@ -4,36 +4,53 @@ This document summarizes the custom LSP capabilities and protocol extensions pro
 
 ## Custom Requests (Client → Server)
 
-| Request                       | Purpose                                                                                                                   |
-| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
-| `deno/cache`                  | Instructs Deno to cache a module and its dependencies. Usually sent as a response to a code action for un-cached modules. |
-| `deno/performance`            | Requests timing averages for Deno's internal instrumentation for monitoring and debugging.                                |
-| `deno/reloadImportRegistries` | Reloads cached responses from import registries.                                                                          |
-| `deno/virtualTextDocument`    | Requests read-only virtual text documents (e.g., cached remote modules or Deno library files) using the `deno:` schema.   |
-| `deno/task`                   | Retrieves a list of available Deno tasks defined in `deno.json` or `deno.jsonc`.                                          |
+| Request                       | Python Method                           | Purpose                                                                                                                   |
+| ----------------------------- | --------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- |
+| `deno/cache`                  | `request_deno_cache`                    | Instructs Deno to cache a module and its dependencies. Usually sent as a response to a code action for un-cached modules. |
+| `deno/performance`            | `request_deno_performance`              | Requests timing averages for Deno's internal instrumentation for monitoring and debugging.                                |
+| `deno/reloadImportRegistries` | `request_deno_reload_import_registries` | Reloads cached responses from import registries.                                                                          |
+| `deno/virtualTextDocument`    | `request_deno_virtual_text_document`    | Requests read-only virtual text documents (e.g., cached remote modules or Deno library files) using the `deno:` schema.   |
+| `deno/task`                   | `request_deno_task`                     | Retrieves a list of available Deno tasks defined in `deno.json` or `deno.jsonc`.                                          |
 
 ## Custom Notifications (Server → Client)
 
-| Notification         | Purpose                                                                                                      |
-| -------------------- | ------------------------------------------------------------------------------------------------------------ |
-| `deno/registryState` | Notifies the client about import registry discovery status, providing suggestions for configuration updates. |
+| Notification         | Python Method                 | Default Behavior                                                                   |
+| -------------------- | ----------------------------- | ---------------------------------------------------------------------------------- |
+| `deno/registryState` | `receive_deno_registry_state` | Logs the registry discovery status and configuration suggestions at `DEBUG` level. |
 
 ## Testing API (Experimental)
 
 Requires `experimental.testingApi` capability to be enabled by both client and server.
 
 ### Requests (Client → Server)
 
-- `deno/testRun`: Initiates a test execution for specified modules or tests.
-- `deno/testRunCancel`: Cancels an ongoing test run by ID.
+| Request              | Python Method                  | Purpose                                                    |
+| -------------------- | ------------------------------ | ---------------------------------------------------------- |
+| `deno/testRun`       | `request_deno_test_run`        | Initiates a test execution for specified modules or tests. |
+| `deno/testRunCancel` | `request_deno_test_run_cancel` | Cancels an ongoing test run by ID.                         |
 
 ### Notifications (Server → Client)
 
-- `deno/testModule`: Sent when a test module is discovered.
-- `deno/testModuleDelete`: Sent when a test module is deleted.
-- `deno/testRunProgress`: Tracks the progress and state of a test run (`enqueued`, `started`, `passed`, `failed`, etc.).
+| Notification            | Python Method                     | Default Behavior                                                                           |
+| ----------------------- | --------------------------------- | ------------------------------------------------------------------------------------------ |
+| `deno/testModule`       | `receive_deno_test_module`        | Logs discovered test module information at `DEBUG` level.                                  |
+| `deno/testModuleDelete` | `receive_deno_test_module_delete` | Logs deleted test module information at `DEBUG` level.                                     |
+| `deno/testRunProgress`  | `receive_deno_test_run_progress`  | Logs test run state (`enqueued`, `started`, `passed`, etc.) and progress at `DEBUG` level. |
 
 ## Other Experimental Capabilities
 
 - `denoConfigTasks`: Support for tasks defined in Deno configuration files.
 - `didRefreshDenoConfigurationTreeNotifications`: Notifications for when the configuration tree is refreshed.
+
+## Deno LSP Documentation
+
+### Official Documentation
+
+- [Language Server Integration](https://docs.deno.com/runtime/reference/lsp_integration/) - Comprehensive guide for integrating with Deno's LSP, including custom capabilities and testing API
+- [deno lsp CLI Reference](https://docs.deno.com/runtime/reference/cli/lsp/) - Basic information about the `deno lsp` subcommand
+- [Deno & Visual Studio Code](https://docs.deno.com/runtime/reference/vscode/) - Complete integration guide and setup
+
+### Source Code & Development
+
+- [Deno CLI LSP Source](https://github.com/denoland/deno/tree/main/cli/lsp) - The actual LSP implementation in Rust
+- [VS Code Extension](https://github.com/denoland/vscode_deno) - Official VS Code extension source code

src/lsp_client/clients/deno/extension.py

@@ -28,29 +28,29 @@
     DENO_TEST_RUN_CANCEL,
     DENO_TEST_RUN_PROGRESS,
     DENO_VIRTUAL_TEXT_DOCUMENT,
-    CacheParams,
-    CacheRequest,
-    CacheResponse,
-    PerformanceRequest,
-    PerformanceResponse,
-    RegistryStatusNotification,
-    ReloadImportRegistriesRequest,
-    ReloadImportRegistriesResponse,
-    TaskRequest,
-    TaskResponse,
-    TestModuleDeleteNotification,
-    TestModuleNotification,
-    TestRunCancelParams,
-    TestRunCancelRequest,
-    TestRunCancelResponse,
-    TestRunProgressNotification,
-    TestRunRequest,
-    TestRunRequestParams,
-    TestRunResponse,
-    TestRunResponseParams,
-    VirtualTextDocumentParams,
-    VirtualTextDocumentRequest,
-    VirtualTextDocumentResponse,
+    DenoCacheParams,
+    DenoCacheRequest,
+    DenoCacheResponse,
+    DenoPerformanceRequest,
+    DenoPerformanceResponse,
+    DenoRegistryStatusNotification,
+    DenoReloadImportRegistriesRequest,
+    DenoReloadImportRegistriesResponse,
+    DenoTaskRequest,
+    DenoTaskResponse,
+    DenoTestModuleDeleteNotification,
+    DenoTestModuleNotification,
+    DenoTestRunCancelParams,
+    DenoTestRunCancelRequest,
+    DenoTestRunCancelResponse,
+    DenoTestRunProgressNotification,
+    DenoTestRunRequest,
+    DenoTestRunRequestParams,
+    DenoTestRunResponse,
+    DenoTestRunResponseParams,
+    DenoVirtualTextDocumentParams,
+    DenoVirtualTextDocumentRequest,
+    DenoVirtualTextDocumentResponse,
 )
 
 
@@ -71,17 +71,17 @@ async def request_deno_cache(
         uris: Sequence[AnyPath] = (),
     ) -> None:
         return await self.request(
-            CacheRequest(
+            DenoCacheRequest(
                 id=jsonrpc_uuid(),
-                params=CacheParams(
+                params=DenoCacheParams(
                     referrer=lsp_type.TextDocumentIdentifier(uri=self.as_uri(referrer)),
                     uris=[
                         lsp_type.TextDocumentIdentifier(uri=self.as_uri(uri))
                         for uri in uris
                     ],
                 ),
             ),
-            schema=CacheResponse,
+            schema=DenoCacheResponse,
         )
 
 
@@ -98,8 +98,8 @@ def methods(cls) -> Sequence[str]:
 
     async def request_deno_performance(self) -> Any:
         return await self.request(
-            PerformanceRequest(id=jsonrpc_uuid()),
-            schema=PerformanceResponse,
+            DenoPerformanceRequest(id=jsonrpc_uuid()),
+            schema=DenoPerformanceResponse,
         )
 
 
@@ -116,8 +116,8 @@ def methods(cls) -> Sequence[str]:
 
     async def request_deno_reload_import_registries(self) -> None:
         return await self.request(
-            ReloadImportRegistriesRequest(id=jsonrpc_uuid()),
-            schema=ReloadImportRegistriesResponse,
+            DenoReloadImportRegistriesRequest(id=jsonrpc_uuid()),
+            schema=DenoReloadImportRegistriesResponse,
         )
 
 
@@ -137,13 +137,13 @@ async def request_deno_virtual_text_document(
         uri: str,
     ) -> str:
         return await self.request(
-            VirtualTextDocumentRequest(
+            DenoVirtualTextDocumentRequest(
                 id=jsonrpc_uuid(),
-                params=VirtualTextDocumentParams(
+                params=DenoVirtualTextDocumentParams(
                     text_document=lsp_type.TextDocumentIdentifier(uri=uri)
                 ),
             ),
-            schema=VirtualTextDocumentResponse,
+            schema=DenoVirtualTextDocumentResponse,
         )
 
 
@@ -160,16 +160,16 @@ def methods(cls) -> Sequence[str]:
 
     async def request_deno_task(self) -> list[Any]:
         return await self.request(
-            TaskRequest(id=jsonrpc_uuid()),
-            schema=TaskResponse,
+            DenoTaskRequest(id=jsonrpc_uuid()),
+            schema=DenoTaskResponse,
         )
 
 
 @runtime_checkable
 class WithRequestDenoTestRun(
+    ExperimentalCapabilityProtocol,
     CapabilityProtocol,
     CapabilityClientProtocol,
-    ExperimentalCapabilityProtocol,
     Protocol,
 ):
     @override
@@ -184,14 +184,14 @@ def register_experimental_capability(cls, cap: dict[str, Any]) -> None:
 
     async def request_deno_test_run(
         self,
-        params: TestRunRequestParams,
-    ) -> TestRunResponseParams:
+        params: DenoTestRunRequestParams,
+    ) -> DenoTestRunResponseParams:
         return await self.request(
-            TestRunRequest(
+            DenoTestRunRequest(
                 id=jsonrpc_uuid(),
                 params=params,
             ),
-            schema=TestRunResponse,
+            schema=DenoTestRunResponse,
         )
 
 
@@ -211,11 +211,11 @@ async def request_deno_test_run_cancel(
         test_run_id: int,
     ) -> None:
         return await self.request(
-            TestRunCancelRequest(
+            DenoTestRunCancelRequest(
                 id=jsonrpc_uuid(),
-                params=TestRunCancelParams(id=test_run_id),
+                params=DenoTestRunCancelParams(id=test_run_id),
             ),
-            schema=TestRunCancelResponse,
+            schema=DenoTestRunCancelResponse,
         )
 
 
@@ -231,7 +231,7 @@ def methods(cls) -> Sequence[str]:
         return (DENO_REGISTRY_STATE,)
 
     async def receive_deno_registry_state(
-        self, noti: RegistryStatusNotification
+        self, noti: DenoRegistryStatusNotification
     ) -> None:
         logger.debug("Received Deno registry state: {}", noti.params)
 
@@ -243,7 +243,7 @@ def register_server_request_hooks(
         registry.register(
             DENO_REGISTRY_STATE,
             ServerNotificationHook(
-                cls=RegistryStatusNotification,
+                cls=DenoRegistryStatusNotification,
                 execute=self.receive_deno_registry_state,
             ),
         )
@@ -260,7 +260,7 @@ class WithReceiveDenoTestModule(
     def methods(cls) -> Sequence[str]:
         return (DENO_TEST_MODULE,)
 
-    async def receive_deno_test_module(self, noti: TestModuleNotification) -> None:
+    async def receive_deno_test_module(self, noti: DenoTestModuleNotification) -> None:
         logger.debug("Received Deno test module: {}", noti.params)
 
     @override
@@ -271,7 +271,7 @@ def register_server_request_hooks(
         registry.register(
             DENO_TEST_MODULE,
             ServerNotificationHook(
-                cls=TestModuleNotification,
+                cls=DenoTestModuleNotification,
                 execute=self.receive_deno_test_module,
             ),
         )
@@ -289,7 +289,7 @@ def methods(cls) -> Sequence[str]:
         return (DENO_TEST_MODULE_DELETE,)
 
     async def receive_deno_test_module_delete(
-        self, noti: TestModuleDeleteNotification
+        self, noti: DenoTestModuleDeleteNotification
     ) -> None:
         logger.debug("Received Deno test module delete: {}", noti.params)
 
@@ -301,7 +301,7 @@ def register_server_request_hooks(
         registry.register(
             DENO_TEST_MODULE_DELETE,
             ServerNotificationHook(
-                cls=TestModuleDeleteNotification,
+                cls=DenoTestModuleDeleteNotification,
                 execute=self.receive_deno_test_module_delete,
             ),
         )
@@ -319,7 +319,7 @@ def methods(cls) -> Sequence[str]:
         return (DENO_TEST_RUN_PROGRESS,)
 
     async def receive_deno_test_run_progress(
-        self, noti: TestRunProgressNotification
+        self, noti: DenoTestRunProgressNotification
     ) -> None:
         logger.debug("Received Deno test run progress: {}", noti.params)
 
@@ -331,7 +331,7 @@ def register_server_request_hooks(
         registry.register(
             DENO_TEST_RUN_PROGRESS,
             ServerNotificationHook(
-                cls=TestRunProgressNotification,
+                cls=DenoTestRunProgressNotification,
                 execute=self.receive_deno_test_run_progress,
             ),
         )