@marimo-team/islands 0.23.11-dev67 → 0.23.11-dev8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marimo-team/islands",
-  "version": "0.23.11-dev67",
+  "version": "0.23.11-dev8",
   "main": "dist/main.js",
   "types": "dist/index.d.ts",
   "type": "module",

package/src/components/datasources/__tests__/column-preview.test.tsx

@@ -0,0 +1,97 @@
+/* Copyright 2026 Marimo. All rights reserved. */
+
+import { render } from "@testing-library/react";
+import { Provider } from "jotai";
+import type React from "react";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { MockRequestClient } from "@/__mocks__/requests";
+import type { SQLTableContext } from "@/core/datasets/data-source-connections";
+import type { DataTable, DataTableColumn } from "@/core/kernel/messages";
+import { requestClientAtom } from "@/core/network/requests";
+import { store } from "@/core/state/jotai";
+import { DatasetColumnPreview } from "../column-preview";
+
+const wrapper = ({ children }: { children: React.ReactNode }) => (
+  <Provider store={store}>{children}</Provider>
+);
+
+const table: DataTable = {
+  name: "users",
+  columns: [],
+  source: "my_engine",
+  // Not "connection"/"catalog", so a preview is requested on mount.
+  source_type: "duckdb",
+  type: "table",
+  engine: "my_engine" as DataTable["engine"],
+  indexes: null,
+  num_columns: null,
+  num_rows: null,
+  variable_name: null,
+  primary_keys: null,
+};
+
+const column = { name: "email" } as DataTableColumn;
+
+function renderPreview(sqlTableContext?: SQLTableContext) {
+  const client = MockRequestClient.create();
+  store.set(requestClientAtom, client);
+  render(
+    <DatasetColumnPreview
+      table={table}
+      column={column}
+      preview={undefined}
+      onAddColumnChart={vi.fn()}
+      sqlTableContext={sqlTableContext}
+    />,
+    { wrapper },
+  );
+  return client;
+}
+
+const ctx = (
+  overrides: Partial<SQLTableContext> & { database: string; schema: string },
+): SQLTableContext => ({
+  engine: "my_engine",
+  dialect: "duckdb",
+  ...overrides,
+});
+
+describe("DatasetColumnPreview fullyQualifiedTableName", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("uses just the table name without a SQL context", () => {
+    const client = renderPreview(undefined);
+    expect(client.previewDatasetColumn).toHaveBeenCalledWith(
+      expect.objectContaining({ fullyQualifiedTableName: "users" }),
+    );
+  });
+
+  it("qualifies with database and schema for flat engines", () => {
+    const client = renderPreview(ctx({ database: "db", schema: "public" }));
+    expect(client.previewDatasetColumn).toHaveBeenCalledWith(
+      expect.objectContaining({ fullyQualifiedTableName: "db.public.users" }),
+    );
+  });
+
+  it("does not emit a double dot for schemaless tables", () => {
+    // Regression: previously produced "db..users".
+    const client = renderPreview(ctx({ database: "db", schema: "" }));
+    expect(client.previewDatasetColumn).toHaveBeenCalledWith(
+      expect.objectContaining({ fullyQualifiedTableName: "db.users" }),
+    );
+  });
+
+  it("includes the full schema path for nested namespaces", () => {
+    // Regression: previously dropped schemaPath and emitted "top.deep.users".
+    const client = renderPreview(
+      ctx({ database: "top", schema: "deep", schemaPath: ["nested", "deep"] }),
+    );
+    expect(client.previewDatasetColumn).toHaveBeenCalledWith(
+      expect.objectContaining({
+        fullyQualifiedTableName: "top.nested.deep.users",
+      }),
+    );
+  });
+});

package/src/components/datasources/__tests__/filter-empty.test.ts

@@ -28,11 +28,15 @@ function makeSchema(opts: {
   name: string;
   tables: DataTable[];
   tables_resolved?: boolean;
+  child_schemas?: DatabaseSchema[];
+  child_schemas_resolved?: boolean;
 }): DatabaseSchema {
   return {
     name: opts.name,
     tables: opts.tables,
     tables_resolved: opts.tables_resolved ?? true,
+    child_schemas: opts.child_schemas ?? [],
+    child_schemas_resolved: opts.child_schemas_resolved ?? true,
   };
 }
 
@@ -180,4 +184,81 @@ describe("filterEmptyDatabases", () => {
 
     expect(databases).toEqual(snapshot);
   });
+
+  it("keeps a namespace that has only child namespaces (no own tables)", () => {
+    const databases = [
+      makeDatabase("iceberg", [
+        makeSchema({
+          name: "top",
+          tables: [],
+          child_schemas: [
+            makeSchema({ name: "nested", tables: [makeTable("t1")] }),
+          ],
+        }),
+      ]),
+    ];
+
+    expect(filterEmptyDatabases(databases)).toBe(databases);
+  });
+
+  it("preserves a namespace whose child schemas are deferred", () => {
+    const databases = [
+      makeDatabase("iceberg", [
+        makeSchema({
+          name: "top",
+          tables: [],
+          child_schemas: [],
+          child_schemas_resolved: false,
+        }),
+      ]),
+    ];
+
+    expect(filterEmptyDatabases(databases)).toBe(databases);
+  });
+
+  it("hides a nested namespace that is resolved-empty", () => {
+    const databases = [
+      makeDatabase("iceberg", [
+        makeSchema({
+          name: "top",
+          tables: [makeTable("t1")],
+          child_schemas: [
+            makeSchema({ name: "empty_child", tables: [] }),
+            makeSchema({ name: "full_child", tables: [makeTable("t2")] }),
+          ],
+        }),
+      ]),
+    ];
+
+    expect(filterEmptyDatabases(databases)).toEqual([
+      makeDatabase("iceberg", [
+        makeSchema({
+          name: "top",
+          tables: [makeTable("t1")],
+          child_schemas: [
+            makeSchema({ name: "full_child", tables: [makeTable("t2")] }),
+          ],
+        }),
+      ]),
+    ]);
+  });
+
+  it("hides a parent namespace when all its descendants are empty", () => {
+    const databases = [
+      makeDatabase("iceberg", [
+        makeSchema({
+          name: "top",
+          tables: [],
+          child_schemas: [makeSchema({ name: "empty_child", tables: [] })],
+        }),
+        makeSchema({ name: "other", tables: [makeTable("t1")] }),
+      ]),
+    ];
+
+    expect(filterEmptyDatabases(databases)).toEqual([
+      makeDatabase("iceberg", [
+        makeSchema({ name: "other", tables: [makeTable("t1")] }),
+      ]),
+    ]);
+  });
 });

package/src/components/datasources/__tests__/utils.test.ts

@@ -4,7 +4,7 @@ import { describe, expect, it } from "vitest";
 import type { SQLTableContext } from "@/core/datasets/data-source-connections";
 import { DUCKDB_ENGINE } from "@/core/datasets/engines";
 import type { DataTable, DataTableColumn } from "@/core/kernel/messages";
-import { sqlCode } from "../utils";
+import { sqlCode, tableUniqueId } from "../utils";
 
 describe("sqlCode", () => {
   const mockTable: DataTable = {
@@ -458,3 +458,64 @@ describe("sqlCode", () => {
     });
   });
 });
+
+describe("tableUniqueId", () => {
+  const ctx = (
+    overrides: Partial<SQLTableContext> & { database: string; schema: string },
+  ): SQLTableContext => ({
+    engine: "e",
+    dialect: "duckdb",
+    ...overrides,
+  });
+
+  it("returns just the table name without a context", () => {
+    expect(tableUniqueId(undefined, "t")).toBe("t");
+  });
+
+  it("uses database + schema for flat engines", () => {
+    expect(tableUniqueId(ctx({ database: "db", schema: "public" }), "t")).toBe(
+      "db.public.t",
+    );
+  });
+
+  it("does not duplicate the leaf schema for nested namespaces", () => {
+    // Regression: previously produced "top.nested.nested.t".
+    expect(
+      tableUniqueId(
+        ctx({ database: "top", schema: "nested", schemaPath: ["nested"] }),
+        "t",
+      ),
+    ).toBe("top.nested.t");
+  });
+
+  it("includes the full schema path for deeply nested namespaces", () => {
+    expect(
+      tableUniqueId(
+        ctx({
+          database: "top",
+          schema: "deep",
+          schemaPath: ["nested", "deep"],
+        }),
+        "t",
+      ),
+    ).toBe("top.nested.deep.t");
+  });
+
+  it("falls back to the flat schema when schemaPath is empty", () => {
+    expect(
+      tableUniqueId(
+        ctx({ database: "db", schema: "public", schemaPath: [] }),
+        "t",
+      ),
+    ).toBe("db.public.t");
+  });
+
+  it("does not emit a double dot for schemaless tables", () => {
+    expect(
+      tableUniqueId(ctx({ database: "db", schema: "", schemaPath: [] }), "t"),
+    ).toBe("db.t");
+    expect(tableUniqueId(ctx({ database: "db", schema: "" }), "t")).toBe(
+      "db.t",
+    );
+  });
+});

package/src/components/datasources/column-preview.tsx

@@ -29,7 +29,7 @@ import { Button } from "../ui/button";
 import { Tooltip } from "../ui/tooltip";
 import { ColumnPreviewContainer } from "./components";
 import { InstallPackageButton } from "./install-package-button";
-import { convertStatsName, sqlCode } from "./utils";
+import { convertStatsName, sqlCode, tableUniqueId } from "./utils";
 
 export const DatasetColumnPreview: React.FC<{
   table: DataTable;
@@ -48,9 +48,7 @@ export const DatasetColumnPreview: React.FC<{
       tableName: table.name,
       columnName: column.name,
       sourceType: table.source_type,
-      fullyQualifiedTableName: sqlTableContext
-        ? `${sqlTableContext.database}.${sqlTableContext.schema}.${table.name}`
-        : table.name,
+      fullyQualifiedTableName: tableUniqueId(sqlTableContext, table.name),
     });
   };
 

package/src/components/datasources/components.tsx

@@ -14,25 +14,31 @@ export const RotatingChevron: React.FC<{ isExpanded: boolean }> = ({
 export const DatasourceLabel: React.FC<{
   children: React.ReactNode;
   className?: string;
-}> = ({ children, className }) => {
+  style?: CSSProperties;
+}> = ({ children, className, style }) => {
   return (
     <div
       className={cn(
         "flex gap-1.5 items-center font-bold py-1.5 text-muted-foreground bg-(--slate-2) text-sm",
         className,
       )}
+      style={style}
     >
       {children}
     </div>
   );
 };
 
-export const EmptyState: React.FC<{ content: string; className?: string }> = ({
-  content,
-  className,
-}) => {
+export const EmptyState: React.FC<{
+  content: string;
+  className?: string;
+  style?: CSSProperties;
+}> = ({ content, className, style }) => {
   return (
-    <div className={cn("text-sm text-muted-foreground py-1", className)}>
+    <div
+      className={cn("text-sm text-muted-foreground py-1", className)}
+      style={style}
+    >
       {content}
     </div>
   );
@@ -61,13 +67,15 @@ export const ErrorState: React.FC<{
 export const LoadingState: React.FC<{
   message: string;
   className?: string;
-}> = ({ message, className }) => {
+  style?: CSSProperties;
+}> = ({ message, className, style }) => {
   return (
     <div
       className={cn(
         "text-sm bg-blue-50 dark:bg-(--accent) text-blue-500 dark:text-blue-50 flex items-center gap-2 p-2 h-8",
         className,
       )}
+      style={style}
     >
       <LoaderCircle className="h-4 w-4 animate-spin" />
       {message}