Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
chore: auto reconnect lsp (#20955)
ecmadao6fac45a5bb94
diff --git a/frontend/src/components/monaco/MonacoEditor.test.tsx b/frontend/src/components/monaco/MonacoEditor.test.tsxindex 1638480637..90b1767841 100644--- a/frontend/src/components/monaco/MonacoEditor.test.tsx+++ b/frontend/src/components/monaco/MonacoEditor.test.tsx@@ -14,6 +14,7 @@ const mocks = vi.hoisted(() => {timestamp: 1_714_000_000_000,},};+ const connectionListeners = new Set<() => void>();const model = {uri: {toString: () => "file:///test.sql",@@ -24,6 +25,9 @@ const mocks = vi.hoisted(() => {getAllDecorations: () => [],};const subscription = { dispose: vi.fn() };+ const handlers = {+ modelContent: undefined as (() => void) | undefined,+ };const editor = {addAction: vi.fn(() => subscription),createDecorationsCollection: vi.fn(() => ({ clear: vi.fn() })),@@ -38,7 +42,10 @@ const mocks = vi.hoisted(() => {onDidChangeCursorPosition: vi.fn(() => subscription),onDidChangeCursorSelection: vi.fn(() => subscription),onDidChangeModel: vi.fn(() => subscription),- onDidChangeModelContent: vi.fn(() => subscription),+ onDidChangeModelContent: vi.fn((handler: () => void) => {+ handlers.modelContent = handler;+ return subscription;+ }),onDidContentSizeChange: vi.fn(() => subscription),setModel: vi.fn(),setValue: vi.fn(),@@ -46,7 +53,15 @@ const mocks = vi.hoisted(() => {};return {connectionSnapshot,+ connectionListeners,+ currentWebSocket: undefined as+ | {+ addEventListener: ReturnType<typeof vi.fn>;+ removeEventListener: ReturnType<typeof vi.fn>;+ }+ | undefined,editor,+ handlers,model,subscription,};@@ -122,11 +137,21 @@ vi.mock("./core", () => ({}));vi.mock("./lsp-client", () => ({+ ensureLSPConnection: vi.fn(async () => ({})),executeCommand: vi.fn(async () => undefined),getConnectionStateSnapshot: vi.fn(() => mocks.connectionSnapshot),- getConnectionWebSocket: vi.fn(() => undefined),+ getConnectionWebSocket: vi.fn(() =>+ mocks.currentWebSocket+ ? Promise.resolve(mocks.currentWebSocket as unknown as WebSocket)+ : undefined+ ),initializeLSPClient: vi.fn(async () => ({})),- subscribeConnectionState: vi.fn(() => () => undefined),+ subscribeConnectionState: vi.fn((listener: () => void) => {+ mocks.connectionListeners.add(listener);+ return () => {+ mocks.connectionListeners.delete(listener);+ };+ }),}));vi.mock("./suggest-icons", () => ({@@ -134,6 +159,9 @@ vi.mock("./suggest-icons", () => ({}));vi.mock("./text-model", () => ({+ getUriByFilename: vi.fn(async (filename: string) => ({+ toString: () => `file:///${filename}`,+ })),getOrCreateTextModel: vi.fn(async () => mocks.model),restoreViewState: vi.fn(),storeViewState: vi.fn(),@@ -169,8 +197,39 @@ const renderIntoContainer = async (beforeEach(() => {vi.clearAllMocks();+ mocks.connectionSnapshot = {+ heartbeat: {+ counter: 1,+ timer: undefined,+ timestamp: 1_714_000_000_000,+ },+ state: "ready",+ };+ mocks.connectionListeners.clear();+ mocks.currentWebSocket = undefined;+ mocks.handlers.modelContent = undefined;+});++const createWebSocket = () => ({+ addEventListener: vi.fn(),+ removeEventListener: vi.fn(),});+const setConnectionState = (state: typeof mocks.connectionSnapshot.state) => {+ mocks.connectionSnapshot = {+ ...mocks.connectionSnapshot,+ state,+ };+};++const notifyConnectionState = async () => {+ act(() => {+ mocks.connectionListeners.forEach((listener) => listener());+ });+ await new Promise((resolve) => setTimeout(resolve, 0));+ await new Promise((resolve) => setTimeout(resolve, 0));+};+describe("MonacoEditor", () => {test("keeps the legacy heartbeat interpolation text", () => {const locale = JSON.parse(@@ -222,4 +281,80 @@ describe("MonacoEditor", () => {unmount();});++ test("rebinds statement-range listener when the LSP socket recovers", async () => {+ const firstWebSocket = createWebSocket();+ const recoveredWebSocket = createWebSocket();+ mocks.currentWebSocket = firstWebSocket;++ const { unmount } = await renderIntoContainer(+ createElement(MonacoEditor, {+ content: "select 1",+ enableDecorations: true,+ })+ );++ expect(firstWebSocket.addEventListener).toHaveBeenCalledWith(+ "message",+ expect.any(Function)+ );++ setConnectionState("closed");+ await notifyConnectionState();+ expect(firstWebSocket.removeEventListener).toHaveBeenCalledWith(+ "message",+ expect.any(Function)+ );++ mocks.currentWebSocket = recoveredWebSocket;+ setConnectionState("ready");+ await notifyConnectionState();++ expect(recoveredWebSocket.addEventListener).toHaveBeenCalledWith(+ "message",+ expect.any(Function)+ );++ unmount();+ });++ test("resends LSP metadata when the connection recovers", async () => {+ const { executeCommand } = await import("./lsp-client");+ setConnectionState("closed");++ const { unmount } = await renderIntoContainer(+ createElement(MonacoEditor, {+ autoCompleteContext: {+ database: "instances/prod/databases/db",+ instance: "instances/prod",+ scene: "query",+ schema: "public",+ },+ content: "select 1",+ })+ );++ await new Promise((resolve) => setTimeout(resolve, 600));+ expect(executeCommand).not.toHaveBeenCalled();++ setConnectionState("ready");+ await notifyConnectionState();+ await new Promise((resolve) => setTimeout(resolve, 600));++ expect(executeCommand).toHaveBeenCalledWith(+ expect.anything(),+ "setMetadata",+ [+ expect.objectContaining({+ databaseName: "db",+ documentUri: expect.stringContaining("file:///"),+ instanceId: "instances/prod",+ scene: "query",+ schema: "public",+ }),+ ]+ );++ unmount();+ });});diff --git a/frontend/src/components/monaco/MonacoEditor.tsx b/frontend/src/components/monaco/MonacoEditor.tsxindex 830e52850f..f4a37394a1 100644--- a/frontend/src/components/monaco/MonacoEditor.tsx+++ b/frontend/src/components/monaco/MonacoEditor.tsx@@ -222,6 +222,8 @@ export function MonacoEditor({getConnectionStateSnapshot,getConnectionStateSnapshot);+ const connectionStateRef = useRef(connection.state);+ connectionStateRef.current = connection.state;const clampMeasuredHeight = (height: number): number => {return Math.min(max, Math.max(min, height));@@ -310,7 +312,6 @@ export function MonacoEditor({let cursorSubscription: { dispose(): void } | null = null;let formatAction: { dispose(): void } | null = null;let suggestStyle: HTMLStyleElement | null = null;- let messageHandler: ((event: MessageEvent) => void) | null = null;const host = document.createElement("div");host.className = "h-full w-full";containerRef.current?.replaceChildren(host);@@ -414,20 +415,6 @@ export function MonacoEditor({suggestStyle = ensureSuggestOverrideStyle();}- if (shouldEnableLSP) {- const wsPromise =- getConnectionWebSocket() ??- initializeLSPClient().then(() => getConnectionWebSocket());- wsPromise?.then((ws) => {- if (!ws || disposed) return;- messageHandler = (message: MessageEvent) => {- processStatementRangeMessage(message);- emitSelectionSideEffects();- };- ws.addEventListener("message", messageHandler);- });- }-if (autoFocus) {editor.focus();}@@ -450,12 +437,6 @@ export function MonacoEditor({cursorSubscription?.dispose();formatAction?.dispose();suggestStyle?.remove();- const wsPromise = getConnectionWebSocket();- if (messageHandler) {- wsPromise?.then((ws) =>- ws.removeEventListener("message", messageHandler!)- );- }// Clear ALL active-statement decorations on the (shared, persistent)// model, not just this instance's tracked id, so teardown can't leave// an orphan highlight behind for the next editor lifecycle.@@ -501,6 +482,36 @@ export function MonacoEditor({t,]);+ useEffect(() => {+ if (!shouldEnableLSP || connection.state !== "ready") {+ return;+ }++ let disposed = false;+ let activeWebSocket: WebSocket | undefined;+ const messageHandler = (message: MessageEvent) => {+ processStatementRangeMessage(message);+ emitSelectionSideEffects();+ };+ const wsPromise = getConnectionWebSocket();+ void wsPromise?.then((ws) => {+ if (!ws || disposed) return;+ activeWebSocket = ws;+ ws.addEventListener("message", messageHandler);+ });++ return () => {+ disposed = true;+ if (activeWebSocket) {+ activeWebSocket.removeEventListener("message", messageHandler);+ return;+ }+ void wsPromise?.then((ws) =>+ ws?.removeEventListener("message", messageHandler)+ );+ };+ }, [connection.state, shouldEnableLSP]);+useEffect(() => {const editor = editorRef.current;const model = modelRef.current ?? editor?.getModel();@@ -597,7 +608,7 @@ export function MonacoEditor({// a writable Monaco for plain text editing don't initialize the LSP// client or send empty `setMetadata` traffic.useEffect(() => {- if (readOnly || !ready) return;+ if (readOnly || !ready || connection.state !== "ready") return;const ctx = autoCompleteContext;if (!ctx) return;const params: {@@ -637,7 +648,13 @@ export function MonacoEditor({return () => {apply.cancel();};- }, [autoCompleteContext, readOnly, ready]);+ }, [+ autoCompleteContext,+ connection.state,+ generatedFilename,+ readOnly,+ ready,+ ]);const height = clampMeasuredHeight(contentHeight);let connectionStateText = t(diff --git a/frontend/src/components/monaco/lsp-client.test.ts b/frontend/src/components/monaco/lsp-client.test.tsnew file mode 100644index 0000000000..446db99dd3--- /dev/null+++ b/frontend/src/components/monaco/lsp-client.test.ts@@ -0,0 +1,408 @@+import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";++const mocks = vi.hoisted(() => ({+ clients: [] as MockLanguageClient[],+ errorNotification: vi.fn(),+ initializeMonacoServices: vi.fn(async () => undefined),+ refreshTokens: vi.fn(async () => undefined),+ sleep: vi.fn(async () => undefined),+ start: vi.fn(async () => undefined),+}));++class MockLanguageClient {+ readonly clientOptions: {+ errorHandler?: {+ closed?: () => { action: number };+ };+ };+ readonly onDidChangeState = vi.fn();+ readonly sendRequest = vi.fn(async () => undefined);+ readonly start = vi.fn(() => mocks.start());+ readonly dispose = vi.fn();++ constructor(+ _id: string,+ _name: string,+ clientOptions: MockLanguageClient["clientOptions"]+ ) {+ this.clientOptions = clientOptions;+ mocks.clients.push(this);+ }+}++class MockWebSocket extends EventTarget {+ static readonly CONNECTING = 0;+ static readonly OPEN = 1;+ static readonly CLOSING = 2;+ static readonly CLOSED = 3;+ static instances: MockWebSocket[] = [];++ readonly close = vi.fn(() => {+ this.readyState = 3;+ this.dispatchClose();+ });+ readonly send = vi.fn();+ readyState = 0;++ constructor(readonly url: string) {+ super();+ MockWebSocket.instances.push(this);+ }++ open() {+ this.readyState = MockWebSocket.OPEN;+ this.dispatchEvent(new Event("open"));+ }++ closeBeforeOpen() {+ this.readyState = 3;+ this.dispatchClose();+ }++ private dispatchClose() {+ const event = new Event("close") as CloseEvent;+ Object.defineProperties(event, {+ code: { value: 1006 },+ reason: { value: "closed" },+ });+ this.dispatchEvent(event);+ }+}++vi.mock("vscode-languageclient", () => ({+ BaseLanguageClient: MockLanguageClient,+ CloseAction: {+ DoNotRestart: 1,+ },+ ErrorAction: {+ Continue: 1,+ },+ State: {+ Running: 2,+ },+}));++vi.mock("vscode-ws-jsonrpc", () => ({+ toSocket: (ws: WebSocket) => ws,+ WebSocketMessageReader: class {+ constructor(readonly _socket: WebSocket) {}+ },+ WebSocketMessageWriter: class {+ constructor(readonly _socket: WebSocket) {}+ },+}));++vi.mock("@/api/refreshToken", () => ({+ refreshTokens: mocks.refreshTokens,+}));++vi.mock("@/utils", () => ({+ sleep: mocks.sleep,+}));++vi.mock("./services", () => ({+ initializeMonacoServices: mocks.initializeMonacoServices,+}));++vi.mock("./utils", () => ({+ createUrl: (_host: string, path: string) =>+ new URL(`ws://example.com${path}`),+ errorNotification: mocks.errorNotification,+ MAX_RETRIES: 5,+ messages: {+ disconnected: () => "WebSocket disconnected",+ },+ progressiveDelay: () => 0,+ WEBSOCKET_HEARTBEAT_INTERVAL: 10_000,+ WEBSOCKET_HEARTBEAT_TIMEOUT: 30_000,+ WEBSOCKET_TIMEOUT: 5_000,+}));++const flushPromises = async () => {+ await Promise.resolve();+ await Promise.resolve();+};++const deferred = <T>() => {+ let resolve!: (value: T | PromiseLike<T>) => void;+ let reject!: (reason?: unknown) => void;+ const promise = new Promise<T>((resolvePromise, rejectPromise) => {+ resolve = resolvePromise;+ reject = rejectPromise;+ });+ return { promise, reject, resolve };+};++beforeEach(() => {+ vi.useFakeTimers();+ vi.resetModules();+ vi.clearAllMocks();+ mocks.start.mockReset();+ mocks.start.mockResolvedValue(undefined);+ mocks.clients.length = 0;+ MockWebSocket.instances = [];+ vi.stubGlobal("WebSocket", MockWebSocket);+});++afterEach(() => {+ vi.unstubAllGlobals();+ vi.restoreAllMocks();+ vi.useRealTimers();+});++describe("LSP client connection recovery", () => {+ test("closes the WebSocket when heartbeat ping does not return", async () => {+ const { initializeLSPClient } = await import("./lsp-client");++ const initializing = initializeLSPClient();+ await flushPromises();+ const ws = MockWebSocket.instances[0];+ ws.open();+ await initializing;++ const client = mocks.clients[0];+ client.sendRequest.mockReturnValueOnce(new Promise(() => undefined));++ await vi.advanceTimersByTimeAsync(10_000);+ expect(client.sendRequest).toHaveBeenCalledWith("$ping", {+ state: {+ counter: 1,+ timestamp: expect.any(Number),+ },+ });++ await vi.advanceTimersByTimeAsync(30_000);+ expect(ws.close).toHaveBeenCalled();+ });++ test("ensureLSPConnection reconnects after the connection reaches closed state", async () => {+ const {+ ensureLSPConnection,+ getConnectionStateSnapshot,+ initializeLSPClient,+ } = await import("./lsp-client");++ const failedInitialConnection = initializeLSPClient().catch(+ () => undefined+ );+ for (let i = 0; i < 5; i++) {+ await flushPromises();+ MockWebSocket.instances[i].closeBeforeOpen();+ }+ await failedInitialConnection;+ expect(getConnectionStateSnapshot().state).toBe("closed");++ const reconnecting = ensureLSPConnection();+ await flushPromises();+ const ws = MockWebSocket.instances[5];+ ws.open();+ await reconnecting;++ expect(mocks.refreshTokens).toHaveBeenCalled();+ expect(getConnectionStateSnapshot().state).toBe("ready");+ });++ test("marks the connection closed when reconnect cannot refresh tokens", async () => {+ const { getConnectionStateSnapshot, initializeLSPClient } = await import(+ "./lsp-client"+ );++ const initializing = initializeLSPClient();+ await flushPromises();+ MockWebSocket.instances[0].open();+ await initializing;+ expect(getConnectionStateSnapshot().state).toBe("ready");++ mocks.refreshTokens.mockRejectedValueOnce(new Error("offline"));+ mocks.clients[0].clientOptions.errorHandler?.closed?.();+ await flushPromises();++ expect(getConnectionStateSnapshot().state).toBe("closed");+ });++ test("automatically retries a closed connection after reconnect fails", async () => {+ const { getConnectionStateSnapshot, initializeLSPClient } = await import(+ "./lsp-client"+ );++ const initializing = initializeLSPClient();+ await flushPromises();+ MockWebSocket.instances[0].open();+ await initializing;++ mocks.refreshTokens.mockRejectedValueOnce(new Error("offline"));+ mocks.clients[0].clientOptions.errorHandler?.closed?.();+ await flushPromises();+ expect(getConnectionStateSnapshot().state).toBe("closed");++ await vi.advanceTimersByTimeAsync(10_000);+ await flushPromises();+ MockWebSocket.instances[1].open();+ await flushPromises();++ expect(mocks.clients).toHaveLength(2);+ expect(getConnectionStateSnapshot().state).toBe("ready");+ });++ test("keeps retrying disconnected connections on the heartbeat interval until success", async () => {+ const { getConnectionStateSnapshot, initializeLSPClient } = await import(+ "./lsp-client"+ );++ const initializing = initializeLSPClient();+ await flushPromises();+ MockWebSocket.instances[0].open();+ await initializing;++ mocks.refreshTokens+ .mockRejectedValueOnce(new Error("offline"))+ .mockRejectedValueOnce(new Error("still offline"));+ mocks.clients[0].clientOptions.errorHandler?.closed?.();+ await flushPromises();+ expect(getConnectionStateSnapshot().state).toBe("closed");++ await vi.advanceTimersByTimeAsync(10_000);+ await flushPromises();+ expect(getConnectionStateSnapshot().state).toBe("closed");++ await vi.advanceTimersByTimeAsync(10_000);+ await flushPromises();+ MockWebSocket.instances[1].open();+ await flushPromises();++ expect(mocks.refreshTokens).toHaveBeenCalledTimes(3);+ expect(mocks.clients).toHaveLength(2);+ expect(getConnectionStateSnapshot().state).toBe("ready");+ });++ test("shares one reconnect attempt across concurrent callers", async () => {+ const {+ ensureLSPConnection,+ getConnectionStateSnapshot,+ initializeLSPClient,+ } = await import("./lsp-client");++ const failedInitialConnection = initializeLSPClient().catch(+ () => undefined+ );+ for (let i = 0; i < 5; i++) {+ await flushPromises();+ MockWebSocket.instances[i].closeBeforeOpen();+ }+ await failedInitialConnection;+ expect(getConnectionStateSnapshot().state).toBe("closed");++ const refresh = deferred<undefined>();+ mocks.refreshTokens.mockReturnValueOnce(refresh.promise);++ const first = ensureLSPConnection();+ const second = ensureLSPConnection();++ expect(first).toBe(second);+ expect(mocks.refreshTokens).toHaveBeenCalledTimes(1);++ refresh.resolve(undefined);+ await flushPromises();+ await flushPromises();+ MockWebSocket.instances[5].open();+ await Promise.all([first, second]);++ expect(mocks.clients).toHaveLength(1);+ expect(getConnectionStateSnapshot().state).toBe("ready");+ });++ test("queues another retry when the active reconnect socket closes during startup", async () => {+ const { getConnectionStateSnapshot, initializeLSPClient } = await import(+ "./lsp-client"+ );++ const initializing = initializeLSPClient();+ await flushPromises();+ MockWebSocket.instances[0].open();+ await initializing;+ expect(getConnectionStateSnapshot().state).toBe("ready");++ const reconnectStart = deferred<undefined>();+ mocks.start.mockReturnValueOnce(reconnectStart.promise);+ mocks.clients[0].clientOptions.errorHandler?.closed?.();+ await flushPromises();++ const reconnectSocket = MockWebSocket.instances[1];+ reconnectSocket.open();+ await flushPromises();+ expect(getConnectionStateSnapshot().state).toBe("ready");++ reconnectSocket.close();+ mocks.clients[1].clientOptions.errorHandler?.closed?.();+ reconnectStart.reject(new Error("connection dropped during startup"));+ await flushPromises();++ expect(getConnectionStateSnapshot().state).toBe("closed");++ await vi.advanceTimersByTimeAsync(10_000);+ await flushPromises();+ MockWebSocket.instances[2].open();+ await flushPromises();++ expect(mocks.clients).toHaveLength(3);+ expect(getConnectionStateSnapshot().state).toBe("ready");+ });++ test("closes the startup socket and disposes the failed client before retrying", async () => {+ const { getConnectionStateSnapshot, initializeLSPClient } = await import(+ "./lsp-client"+ );++ mocks.start.mockRejectedValueOnce(new Error("initialize rejected"));++ const initializing = initializeLSPClient().catch(() => undefined);+ await flushPromises();+ const ws = MockWebSocket.instances[0];+ ws.open();+ await flushPromises();+ await initializing;++ expect(ws.close).toHaveBeenCalled();+ expect(mocks.clients[0].dispose).toHaveBeenCalled();+ expect(getConnectionStateSnapshot().state).toBe("closed");++ await vi.advanceTimersByTimeAsync(10_000);+ await flushPromises();+ MockWebSocket.instances[1].open();+ await flushPromises();++ expect(mocks.clients).toHaveLength(2);+ expect(getConnectionStateSnapshot().state).toBe("ready");+ });++ test("does not let a stale startup failure close a recovered client", async () => {+ const { getConnectionStateSnapshot, initializeLSPClient } = await import(+ "./lsp-client"+ );++ const staleStart = deferred<undefined>();+ mocks.start.mockReturnValueOnce(staleStart.promise);++ const staleInitializing = initializeLSPClient().catch(() => undefined);+ await flushPromises();+ const staleSocket = MockWebSocket.instances[0];+ staleSocket.open();+ await flushPromises();+ expect(getConnectionStateSnapshot().state).toBe("ready");++ staleSocket.close();+ mocks.clients[0].clientOptions.errorHandler?.closed?.();+ await flushPromises();+ const recoveredSocket = MockWebSocket.instances[1];+ recoveredSocket.open();+ await flushPromises();+ expect(getConnectionStateSnapshot().state).toBe("ready");++ staleStart.reject(new Error("stale initialize rejected"));+ await staleInitializing;++ expect(mocks.clients[1].dispose).not.toHaveBeenCalled();+ expect(recoveredSocket.close).not.toHaveBeenCalled();+ expect(getConnectionStateSnapshot().state).toBe("ready");+ });+});diff --git a/frontend/src/components/monaco/lsp-client.ts b/frontend/src/components/monaco/lsp-client.tsindex 5eb3156aa4..fade8a6847 100644--- a/frontend/src/components/monaco/lsp-client.ts+++ b/frontend/src/components/monaco/lsp-client.ts@@ -25,6 +25,7 @@ import {messages,progressiveDelay,WEBSOCKET_HEARTBEAT_INTERVAL,+ WEBSOCKET_HEARTBEAT_TIMEOUT,WEBSOCKET_TIMEOUT,} from "./utils";@@ -41,6 +42,12 @@ export type ConnectionState = {ws: Promise<WebSocket> | undefined;};+type LanguageClientConnection = {+ client: MonacoLanguageClient;+ ws: WebSocket;+ wsPromise: Promise<WebSocket>;+};+// Inline replacement for `monaco-languageclient`'s `MonacoLanguageClient`,// which was a ~15-line subclass and the only thing we consumed from that// package. All the LSP machinery lives in `vscode-languageclient`, whose@@ -110,6 +117,8 @@ const state = {client: undefined as MonacoLanguageClient | undefined,clientInitialized: undefined as Promise<MonacoLanguageClient> | undefined,};+let reconnectHeartbeatTimer: ReturnType<typeof setTimeout> | undefined;+let reconnectJob: Promise<MonacoLanguageClient> | undefined;const setConnState = (patch: Partial<ConnectionState>) => {Object.assign(conn, patch);@@ -129,37 +138,81 @@ const setHeartbeat = (patch: Partial<ConnectionState["heartbeat"]>) => {emit();};-const useHeartbeat = (ws: WebSocket) => {+const clearHeartbeat = () => {+ clearTimeout(conn.heartbeat.timer);+ conn.heartbeat = {+ timer: undefined,+ counter: 0,+ timestamp: 0,+ };+ emit();+};++const clearReconnectHeartbeat = () => {+ clearTimeout(reconnectHeartbeatTimer);+ reconnectHeartbeatTimer = undefined;+};++const scheduleReconnectHeartbeat = () => {+ if (reconnectHeartbeatTimer || conn.state === "ready") {+ return;+ }+ reconnectHeartbeatTimer = setTimeout(() => {+ reconnectHeartbeatTimer = undefined;+ void reconnect().catch(() => undefined);+ }, WEBSOCKET_HEARTBEAT_INTERVAL);+};++const startHeartbeat = (client: MonacoLanguageClient, ws: WebSocket) => {+ let active = true;+ let heartbeatResponseTimer: ReturnType<typeof setTimeout> | undefined;+const cleanup = () => {- clearTimeout(conn.heartbeat.timer);- conn.heartbeat = {- timer: undefined,- counter: 0,- timestamp: 0,- };- emit();+ active = false;+ clearTimeout(heartbeatResponseTimer);+ clearHeartbeat();};ws.addEventListener("error", cleanup);ws.addEventListener("close", cleanup);const ping = () => {+ clearTimeout(heartbeatResponseTimer);+ const counter = conn.heartbeat.counter + 1;+ const timestamp = Date.now();setHeartbeat({- counter: conn.heartbeat.counter + 1,- timestamp: Date.now(),+ counter,+ timestamp,});- ws.send(- JSON.stringify({- jsonrpc: "2.0",- method: "$ping",- params: {- state: omit(conn.heartbeat, "timer"),- },++ heartbeatResponseTimer = setTimeout(() => {+ if (active && ws.readyState === WebSocket.OPEN) {+ ws.close();+ }+ }, WEBSOCKET_HEARTBEAT_TIMEOUT);++ void Promise.resolve(+ client.sendRequest("$ping", {+ state: omit(conn.heartbeat, "timer"),})- );- setHeartbeat({- timer: setTimeout(ping, WEBSOCKET_HEARTBEAT_INTERVAL),- });+ )+ .then(() => {+ if (!active) {+ return;+ }+ clearTimeout(heartbeatResponseTimer);+ heartbeatResponseTimer = undefined;+ if (ws.readyState === WebSocket.OPEN) {+ setHeartbeat({+ timer: setTimeout(ping, WEBSOCKET_HEARTBEAT_INTERVAL),+ });+ }+ })+ .catch(() => {+ if (active && ws.readyState === WebSocket.OPEN) {+ ws.close();+ }+ });};ping();@@ -214,8 +267,8 @@ const connectWebSocket = () => {if (conn.state === "ready" || conn.state === "closed") {return;}+ clearReconnectHeartbeat();setConnState({ state: "ready", retries: 0 });- useHeartbeat(ws);resolve(ws);});@@ -231,15 +284,7 @@ const connectWebSocket = () => {return promise;};-const reconnect = async () => {- setConnState({- ws: undefined,- state: "initial",- retries: 0,- });-- await refreshTokens();-+const disposeClient = () => {if (state.client) {try {state.client.dispose();@@ -249,10 +294,44 @@ const reconnect = async () => {state.client = undefined;}state.clientInitialized = undefined;- await initializeLSPClient();};-const createLanguageClient = async (): Promise<MonacoLanguageClient> => {+const reconnectRunner = async () => {+ setConnState({+ ws: undefined,+ state: "initial",+ retries: 0,+ });++ clearReconnectHeartbeat();+ disposeClient();+ try {+ await refreshTokens();+ } catch (err) {+ setConnState({+ ws: undefined,+ state: "closed",+ retries: 0,+ });+ scheduleReconnectHeartbeat();+ throw err;+ }++ return initializeLSPClient();+};++const reconnect = () => {+ if (reconnectJob) {+ return reconnectJob;+ }++ reconnectJob = reconnectRunner().finally(() => {+ reconnectJob = undefined;+ });+ return reconnectJob;+};++const createLanguageClient = async (): Promise<LanguageClientConnection> => {// `vscode-languageclient` touches the `vscode` API at construction time,// which requires `@codingame/monaco-vscode-api`'s `initialize()` to have// completed before `new MonacoLanguageClient(...)`,@@ -264,51 +343,57 @@ const createLanguageClient = async (): Promise<MonacoLanguageClient> => {// caller to have initialized services first. Await it here so callers// can fire-and-forget safely.await initializeMonacoServices();- const ws = await connectWebSocket();+ const wsPromise = connectWebSocket();+ const ws = await wsPromise;const socket = toSocket(ws);const reader = new WebSocketMessageReader(socket);const writer = new WebSocketMessageWriter(socket);- return new MonacoLanguageClient({- name: "Bytebase Language Client",- clientOptions: {- documentSelector: ["sql", "javascript"],- initializationOptions: {- performanceMode: true,- diagnosticDelay: 500,- disableFeaturesWhileTyping: true,- },- middleware: {- provideHover: throttle(async (document, position, token, next) => {- return next(document, position, token);- }, 300),- provideCompletionItem: throttle(- async (document, position, context, token, next) => {- const triggerCharacters = [".", ",", "(", " "];- if (- context.triggerKind === 1 &&- !triggerCharacters.includes(context.triggerCharacter || "")- ) {- return { items: [] };- }- return next(document, position, context, token);+ return {+ client: new MonacoLanguageClient({+ name: "Bytebase Language Client",+ clientOptions: {+ documentSelector: ["sql", "javascript"],+ initializationOptions: {+ performanceMode: true,+ diagnosticDelay: 500,+ disableFeaturesWhileTyping: true,+ },+ middleware: {+ provideHover: throttle(async (document, position, token, next) => {+ return next(document, position, token);+ }, 300),+ provideCompletionItem: throttle(+ async (document, position, context, token, next) => {+ const triggerCharacters = [".", ",", "(", " "];+ if (+ context.triggerKind === 1 &&+ !triggerCharacters.includes(context.triggerCharacter || "")+ ) {+ return { items: [] };+ }+ return next(document, position, context, token);+ },+ 200+ ),+ },+ errorHandler: {+ error: () => ({ action: ErrorAction.Continue }),+ closed: () => {+ reconnect().catch((err) => errorNotification(err));+ return { action: CloseAction.DoNotRestart };},- 200- ),- },- errorHandler: {- error: () => ({ action: ErrorAction.Continue }),- closed: () => {- reconnect().catch((err) => errorNotification(err));- return { action: CloseAction.DoNotRestart };},},- },- messageTransports: { reader, writer },- });+ messageTransports: { reader, writer },+ }),+ ws,+ wsPromise,+ };};const initializeRunner = async () => {- const client = await createLanguageClient();+ const { client, ws, wsPromise } = await createLanguageClient();+ const isCurrentConnection = () => conn.ws === wsPromise;client.onDidChangeState((event) => {if (event.newState === State.Running) {const { lastCommand } = conn;@@ -318,13 +403,45 @@ const initializeRunner = async () => {}});- try {- await client.start();- } catch (err) {- errorNotification(err);- }+ await client.start().catch((err) => {+ try {+ client.dispose();+ } catch {+ // ignore+ }+ if (+ ws.readyState !== WebSocket.CLOSING &&+ ws.readyState !== WebSocket.CLOSED+ ) {+ ws.close();+ }+ if (isCurrentConnection()) {+ setConnState({+ ws: undefined,+ state: "closed",+ retries: 0,+ });+ scheduleReconnectHeartbeat();+ }+ throw err;+ });+ if (!isCurrentConnection()) {+ try {+ client.dispose();+ } catch {+ // ignore+ }+ if (+ ws.readyState !== WebSocket.CLOSING &&+ ws.readyState !== WebSocket.CLOSED+ ) {+ ws.close();+ }+ return client;+ }state.client = client;+ startHeartbeat(client, ws);return client;};@@ -332,11 +449,35 @@ export const initializeLSPClient = () => {if (state.clientInitialized) {return state.clientInitialized;}- const job = initializeRunner();+ let job: Promise<MonacoLanguageClient>;+ job = initializeRunner().catch((err) => {+ if (state.clientInitialized === job) {+ disposeClient();+ if (conn.state !== "ready") {+ setConnState({+ ws: undefined,+ state: "closed",+ retries: 0,+ });+ scheduleReconnectHeartbeat();+ }+ }+ throw err;+ });state.clientInitialized = job;return job;};+export const ensureLSPConnection = () => {+ if (conn.state === "ready" || conn.state === "reconnecting") {+ return state.clientInitialized ?? initializeLSPClient();+ }+ if (conn.state === "initial" && conn.ws) {+ return state.clientInitialized ?? initializeLSPClient();+ }+ return reconnect();+};+export const executeCommand = async (client: MonacoLanguageClient,command: string,diff --git a/frontend/src/components/monaco/utils.ts b/frontend/src/components/monaco/utils.tsindex b0b623e3c8..a158e4a2d0 100644--- a/frontend/src/components/monaco/utils.ts+++ b/frontend/src/components/monaco/utils.ts@@ -13,6 +13,7 @@ export const RECONNECTION_DELAY = {};export const WEBSOCKET_TIMEOUT = 5000;export const WEBSOCKET_HEARTBEAT_INTERVAL = 10 * 1000;+export const WEBSOCKET_HEARTBEAT_TIMEOUT = 30 * 1000;type MonacoMessages = {title: string;