@marimo-team/islands 0.25.3-dev312 → 0.25.3-dev317

package/src/core/network/__tests__/requests-lazy.test.ts

@@ -1,322 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { requestId, uiElementId } from "@/__tests__/branded";
-import { waitForRuntimeRunning } from "../../executions";
-import type { RuntimeManager } from "../../runtime/runtime";
-import { waitForConnectionOpen } from "../connection";
-import { createLazyRequests } from "../requests-lazy";
-import type {
-  EditRequests,
-  ExportAvailabilityResponse,
-  RunRequests,
-} from "../types";
-
-// Mock the connection module
-vi.mock("../connection", async () => {
-  const { atom } = await import("jotai");
-  return {
-    connectionAtom: atom({ state: "NOT_STARTED" }),
-    waitForConnectionOpen: vi.fn().mockResolvedValue(undefined),
-  };
-});
-
-// Mock the kernel state module
-vi.mock("../../executions", () => ({
-  waitForRuntimeRunning: vi.fn().mockResolvedValue(undefined),
-}));
-
-describe("createLazyRequests", () => {
-  let mockDelegate: EditRequests & RunRequests;
-  let mockRuntimeManager: RuntimeManager;
-  let mockGetRuntimeManager: () => RuntimeManager;
-  let mockInit: ReturnType<typeof vi.fn>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    // Mock init function
-    mockInit = vi.fn().mockResolvedValue(undefined);
-
-    // Mock runtime manager
-    mockRuntimeManager = {
-      init: mockInit,
-      isLazy: true,
-    } as unknown as RuntimeManager;
-
-    // Mock getter function
-    mockGetRuntimeManager = vi.fn(() => mockRuntimeManager);
-
-    // Mock delegate with some sample methods
-    mockDelegate = {
-      sendInstantiate: vi.fn().mockResolvedValue({ instantiated: true }),
-      sendFunctionRequest: vi.fn().mockResolvedValue({ result: "data" }),
-      sendRestart: vi.fn().mockResolvedValue({ restarted: true }),
-      sendInterrupt: vi.fn().mockResolvedValue({ interrupted: true }),
-      sendPdb: vi.fn().mockResolvedValue({ pdb: true }),
-      sendRunScratchpad: vi.fn().mockResolvedValue({ run: true }),
-      installExportRequirements: vi.fn().mockResolvedValue({
-        source: "server",
-        formats: [],
-      }),
-    } as unknown as EditRequests & RunRequests;
-  });
-
-  it("passes server-only requests through without starting a kernel", async () => {
-    const environment = { marimo: "1.2.3" };
-    mockDelegate.getEnvironmentInfo = vi
-      .fn()
-      .mockResolvedValue(environment) as EditRequests["getEnvironmentInfo"];
-
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-
-    await expect(lazyRequests.getEnvironmentInfo()).resolves.toEqual(
-      environment,
-    );
-    expect(mockInit).not.toHaveBeenCalled();
-    expect(mockDelegate.getEnvironmentInfo).toHaveBeenCalledOnce();
-  });
-
-  it("gets export availability without starting a kernel", async () => {
-    const availability: ExportAvailabilityResponse = {
-      source: "server",
-      formats: [
-        {
-          format: "ipynb",
-          dependenciesAvailable: false,
-          missingPackages: ["nbformat"],
-          missingSetup: [],
-        },
-      ],
-    };
-    mockDelegate.getExportAvailability = vi
-      .fn()
-      .mockResolvedValue(availability) as EditRequests["getExportAvailability"];
-
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-
-    await expect(lazyRequests.getExportAvailability()).resolves.toEqual(
-      availability,
-    );
-    expect(mockInit).not.toHaveBeenCalled();
-    expect(mockDelegate.getExportAvailability).toHaveBeenCalledOnce();
-  });
-
-  it("installs export requirements without waiting for the kernel", async () => {
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-
-    await lazyRequests.installExportRequirements({ format: "pdf" });
-
-    expect(mockInit).toHaveBeenCalledOnce();
-    expect(waitForConnectionOpen).toHaveBeenCalledOnce();
-    expect(waitForRuntimeRunning).not.toHaveBeenCalled();
-    expect(mockDelegate.installExportRequirements).toHaveBeenCalledWith({
-      format: "pdf",
-    });
-  });
-
-  it("sends instantiate without waiting for the kernel", async () => {
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-    const request = {
-      objectIds: [uiElementId("obj1")],
-      values: [],
-    };
-
-    await lazyRequests.sendInstantiate(request);
-
-    expect(mockInit).toHaveBeenCalledOnce();
-    expect(waitForConnectionOpen).toHaveBeenCalledOnce();
-    expect(waitForRuntimeRunning).not.toHaveBeenCalled();
-    expect(mockDelegate.sendInstantiate).toHaveBeenCalledWith(request);
-  });
-
-  it("should call init once before first request", async () => {
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-
-    await lazyRequests.sendRunScratchpad({ code: "code" });
-
-    expect(mockInit).toHaveBeenCalledTimes(1);
-  });
-
-  it("starts the kernel for datasource discovery", async () => {
-    mockDelegate.discoverDataSources = vi.fn().mockResolvedValue(null);
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-
-    await lazyRequests.discoverDataSources({
-      requestId: requestId("discovery"),
-    });
-
-    expect(mockInit).toHaveBeenCalledOnce();
-    expect(mockDelegate.discoverDataSources).toHaveBeenCalledOnce();
-  });
-
-  it("should only call init once across multiple requests", async () => {
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-
-    await lazyRequests.sendRunScratchpad({ code: "code" });
-    await lazyRequests.sendInstantiate({
-      objectIds: [uiElementId("obj1")],
-      values: [],
-    });
-    await lazyRequests.sendFunctionRequest({
-      functionCallId: requestId("func1"),
-      functionName: "testFunc",
-      args: {},
-      namespace: "test",
-    });
-
-    expect(mockInit).toHaveBeenCalledTimes(1);
-  });
-
-  it("should wait for connection before calling delegate method", async () => {
-    const { waitForConnectionOpen } = await import("../connection");
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-
-    await lazyRequests.sendRunScratchpad({ code: "code" });
-
-    expect(waitForConnectionOpen).toHaveBeenCalled();
-  });
-
-  it("should call delegate method with correct arguments", async () => {
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-
-    const args = { code: "code" };
-    await lazyRequests.sendRunScratchpad(args);
-
-    expect(mockDelegate.sendRunScratchpad).toHaveBeenCalledWith(args);
-  });
-
-  it("should return the result from delegate method", async () => {
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-
-    const result = await lazyRequests.sendFunctionRequest({
-      functionCallId: requestId("func1"),
-      functionName: "testFunc",
-      args: {},
-      namespace: "test",
-    });
-
-    expect(result).toEqual({ result: "data" });
-  });
-
-  it("should wrap all methods from delegate", () => {
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-
-    expect(lazyRequests.sendRunScratchpad).toBeDefined();
-    expect(lazyRequests.sendInstantiate).toBeDefined();
-    expect(lazyRequests.sendFunctionRequest).toBeDefined();
-  });
-
-  it("should handle errors from init", async () => {
-    const error = new Error("Init failed");
-    mockInit.mockRejectedValue(error);
-
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-
-    await expect(
-      lazyRequests.sendRunScratchpad({ code: "code" }),
-    ).rejects.toThrow("Init failed");
-  });
-
-  it("should handle errors from delegate method", async () => {
-    const error = new Error("Request failed");
-    mockDelegate.sendRunScratchpad = vi.fn().mockRejectedValue(error);
-
-    const lazyRequests = createLazyRequests(
-      mockDelegate,
-      mockGetRuntimeManager,
-    );
-
-    await expect(
-      lazyRequests.sendRunScratchpad({ code: "code" }),
-    ).rejects.toThrow("Request failed");
-  });
-
-  describe("Memoization", () => {
-    it("should re-initialize if runtime manager changes", async () => {
-      const lazyRequests = createLazyRequests(
-        mockDelegate,
-        mockGetRuntimeManager,
-      );
-
-      // First request with first runtime manager
-      await lazyRequests.sendRunScratchpad({ code: "code" });
-      expect(mockInit).toHaveBeenCalledTimes(1);
-
-      // Create a new runtime manager
-      const mockInit2 = vi.fn().mockResolvedValue(undefined);
-      const mockRuntimeManager2 = {
-        init: mockInit2,
-        isLazy: true,
-      } as unknown as RuntimeManager;
-      mockGetRuntimeManager = vi.fn(() => mockRuntimeManager2);
-
-      // Create new lazy requests with new getter
-      const lazyRequests2 = createLazyRequests(
-        mockDelegate,
-        mockGetRuntimeManager,
-      );
-
-      // Second request with second runtime manager
-      await lazyRequests2.sendRunScratchpad({ code: "code" });
-
-      // Both inits should have been called
-      expect(mockInit).toHaveBeenCalledTimes(1);
-      expect(mockInit2).toHaveBeenCalledTimes(1);
-    });
-
-    it("should only initialize once per runtime manager instance", async () => {
-      const lazyRequests = createLazyRequests(
-        mockDelegate,
-        mockGetRuntimeManager,
-      );
-
-      // Multiple requests
-      await lazyRequests.sendRunScratchpad({ code: "code" });
-      await lazyRequests.sendInstantiate({
-        objectIds: [uiElementId("obj1")],
-        values: [],
-      });
-
-      // Init should only be called once
-      expect(mockInit).toHaveBeenCalledTimes(1);
-      expect(mockGetRuntimeManager).toHaveBeenCalledTimes(2);
-    });
-  });
-});

package/src/core/network/requests-lazy.ts

@@ -1,222 +0,0 @@
-/* Copyright 2026 Marimo. All rights reserved. */
-
-import { NoKernelConnectedError } from "@/utils/errors";
-import { Logger } from "@/utils/Logger";
-import { Objects } from "@/utils/objects";
-import { memoizeLastValue } from "@/utils/once";
-import { waitForRuntimeRunning } from "../executions";
-import type { RuntimeManager } from "../runtime/runtime";
-import { store } from "../state/jotai";
-import { ConnectionState } from "../session/types";
-import { connectionAtom, waitForConnectionOpen } from "./connection";
-import type { EditRequests, RunRequests } from "./types";
-
-type AllRequests = EditRequests & RunRequests;
-
-// We have various requests that act differently when called and not connected to a Kernel:
-//
-// - throwError: Throws NoKernelConnectedError, caught by requests-toasting.tsx
-//   and shown as a toast with a "Connect" button. Use for operations that
-//   shouldn't silently fail but also shouldn't auto-start the kernel.
-//
-// - dropRequest: Silently returns undefined. Only for requests where failure is
-//   expected and doesn't matter (e.g., background polling).
-//
-// - startConnection: Initializes the runtime and waits for connection before
-//   executing. Use for user-initiated actions that should "just work" and
-//   kick off the kernel if needed (e.g., clicking Run).
-//
-// - startConnectionWithoutKernel: Initializes the runtime and waits for an open
-//   connection. Use for session-scoped server requests that do not need an
-//   instantiated kernel.
-//
-// - waitForConnectionOpen: Waits for an existing connection but won't start one.
-//   Use for operations that depend on a running kernel but shouldn't be the
-//   trigger to start it (e.g., saving, interrupting).
-//
-// - serverOnly: Calls the HTTP delegate directly without touching the kernel.
-//   Use for requests served by the marimo server itself, which resolve without
-//   a session (e.g., fetching environment diagnostics).
-
-type Action =
-  | "throwError"
-  | "dropRequest"
-  | "startConnection"
-  | "startConnectionWithoutKernel"
-  | "waitForConnectionOpen"
-  | "serverOnly";
-
-const ACTIONS: Record<keyof AllRequests, Action> = {
-  // These will start a connection if not already connected and then wait until the connection is open
-  sendComponentValues: "startConnection",
-  sendModelValue: "startConnection",
-  sendInstantiate: "startConnectionWithoutKernel",
-  sendRunScratchpad: "startConnection",
-  saveAppConfig: "startConnection",
-  discoverDataSources: "startConnection",
-
-  // Export operations start a connection
-  exportAsHTML: "startConnection",
-  exportAsIPYNB: "startConnection",
-  exportAsMarkdown: "startConnection",
-  exportAsScript: "startConnection",
-  exportAsPDF: "startConnection",
-  readCode: "startConnection",
-  sendCopy: "throwError",
-
-  // Throw errors for operations that are not supported offline
-  sendFormat: "throwError",
-  sendRestart: "throwError",
-
-  // These wait until the connection is open, but don't start a connection
-  saveLayout: "waitForConnectionOpen",
-  invokeAiTool: "waitForConnectionOpen",
-  sendFunctionRequest: "waitForConnectionOpen",
-
-  // Session-based operations that wait for connection
-  sendRename: "waitForConnectionOpen",
-  autoExportAsHTML: "waitForConnectionOpen",
-  autoExportAsMarkdown: "waitForConnectionOpen",
-  autoExportAsIPYNB: "waitForConnectionOpen",
-  updateCellOutputs: "waitForConnectionOpen",
-
-  // Sidebar operations that wait for connection
-  listSecretKeys: "throwError",
-  writeSecret: "throwError",
-  clearCache: "throwError",
-  getCacheInfo: "throwError",
-
-  // Operations that throw errors (sessionless but not supported offline)
-  saveUserConfig: "throwError",
-  sendShutdown: "throwError",
-  getPackageList: "throwError",
-  getSandbox: "serverOnly",
-  updateManifest: "serverOnly",
-  syncSandbox: "serverOnly",
-  getDependencyTree: "throwError",
-  addPackage: "throwError",
-  removePackage: "throwError",
-
-  // Folder and file operations throw errors
-  getFileRoots: "startConnection",
-  sendListFiles: "startConnection",
-  sendSearchFiles: "startConnection",
-  sendCreateFileOrFolder: "throwError",
-  sendDeleteFileOrFolder: "throwError",
-  sendCopyFileOrFolder: "throwError",
-  sendRenameFileOrFolder: "throwError",
-  sendUpdateFile: "throwError",
-  sendFileDetails: "throwError",
-  openFile: "throwError",
-
-  // Served by the marimo server without a kernel session
-  getEnvironmentInfo: "serverOnly",
-  getExportAvailability: "serverOnly",
-
-  // Session-scoped server operations
-  installExportRequirements: "startConnectionWithoutKernel",
-
-  // Home operations throw errors
-  getRecentFiles: "startConnection",
-  getWorkspaceFiles: "startConnection",
-  getRunningNotebooks: "startConnection",
-  shutdownSession: "startConnection",
-  openTutorial: "startConnection",
-  getUsageStats: "waitForConnectionOpen",
-
-  // These wait for connection
-  sendStdin: "waitForConnectionOpen",
-  sendInterrupt: "waitForConnectionOpen",
-  sendPdb: "waitForConnectionOpen",
-  sendSetBreakpoints: "waitForConnectionOpen",
-  sendInstallMissingPackages: "waitForConnectionOpen",
-  readSnippets: "waitForConnectionOpen",
-  previewDatasetColumn: "waitForConnectionOpen",
-  previewSQLTable: "waitForConnectionOpen",
-  previewSQLTableList: "waitForConnectionOpen",
-  previewSQLSchemaList: "waitForConnectionOpen",
-  previewDataSourceConnection: "waitForConnectionOpen",
-  validateSQL: "waitForConnectionOpen",
-  listStorageEntries: "waitForConnectionOpen",
-  downloadStorage: "waitForConnectionOpen",
-
-  // Sync operations that wait for connection
-  sendCodeCompletionRequest: "waitForConnectionOpen",
-};
-
-/**
- * Create a lazy requests client.
- * On any request, we will initialize the runtime manager (if not already initialized)
- * and handle it based on the action type defined in ACTIONS.
- */
-export function createLazyRequests(
-  delegate: AllRequests,
-  getRuntimeManager: () => RuntimeManager,
-): AllRequests {
-  // Memoize the init call, just once per runtime manager
-  const initOnce = memoizeLastValue(async (runtimeManager: RuntimeManager) => {
-    store.set(connectionAtom, { state: ConnectionState.CONNECTING });
-    await runtimeManager.init();
-  });
-
-  // oxlint-disable-next-line typescript/no-explicit-any
-  function wrapRequest<T extends (...args: any[]) => Promise<any>>(
-    request: T,
-    key: keyof AllRequests,
-  ): T {
-    const action = ACTIONS[key];
-
-    const wrapped = (async (...args) => {
-      const runtimeManager = getRuntimeManager();
-
-      if (!runtimeManager.isLazy) {
-        return request(...args);
-      }
-
-      switch (action) {
-        case "serverOnly":
-          // Served by the marimo server itself; no kernel required
-          return request(...args);
-
-        case "dropRequest":
-          Logger.debug(
-            `Dropping request: ${key}, since not connected to a kernel.`,
-          );
-          // Silently drop the request
-          return;
-
-        case "throwError":
-          throw new NoKernelConnectedError();
-
-        case "waitForConnectionOpen":
-          // Wait for connection but don't start it
-          await waitForConnectionOpen();
-          await waitForRuntimeRunning(store);
-          return request(...args);
-
-        case "startConnectionWithoutKernel":
-        case "startConnection":
-          // Start connection and wait for it to be open
-          await initOnce(runtimeManager);
-          await waitForConnectionOpen();
-          if (action === "startConnection") {
-            await waitForRuntimeRunning(store);
-          }
-          return request(...args);
-
-        default:
-          // This should never happen if ACTIONS is complete
-          throw new Error(`Unknown action for "${key}"`);
-      }
-    }) as T;
-    return wrapped;
-  }
-
-  return Objects.mapValues(delegate, (value, key) => {
-    return wrapRequest(value, key);
-  }) as AllRequests;
-}
-
-export const visibleForTesting = {
-  ACTIONS,
-};