set up ResourceContainer for Flink database and Kafka cluster child resources

src/commands/flinkArtifacts.test.ts

@@ -12,7 +12,7 @@ import type {
   PresignedUploadUrlArtifactV1PresignedUrl200ResponseKindEnum,
 } from "../clients/flinkArtifacts/models/PresignedUploadUrlArtifactV1PresignedUrl200Response";
 import type { FlinkArtifact } from "../models/flinkArtifact";
-import { FlinkDatabaseResourceContainer } from "../models/flinkDatabaseResourceContainer";
+import { FlinkDatabaseResourceContainer } from "../models/containers/flinkDatabaseResourceContainer";
 import { type EnvironmentId } from "../models/resource";
 import * as notifications from "../notifications";
 import { FlinkDatabaseViewProvider } from "../viewProviders/flinkDatabase";

src/commands/flinkDatabaseView.test.ts

@@ -21,7 +21,7 @@ import type { CCloudResourceLoader } from "../loaders";
 import {
   FlinkDatabaseContainerLabel,
   FlinkDatabaseResourceContainer,
-} from "../models/flinkDatabaseResourceContainer";
+} from "../models/containers/flinkDatabaseResourceContainer";
 import { FlinkDatabaseViewProvider } from "../viewProviders/flinkDatabase";
 
 describe("commands/flinkDatabaseView.ts", () => {

src/commands/flinkDatabaseView.ts

@@ -4,8 +4,8 @@ import { setFlinkDocumentMetadata } from "../flinkSql/statementUtils";
 import { CCloudResourceLoader } from "../loaders";
 import { Logger } from "../logging";
 import type { CCloudEnvironment } from "../models/environment";
-import type { FlinkDatabaseResourceContainer } from "../models/flinkDatabaseResourceContainer";
-import { FlinkDatabaseContainerLabel } from "../models/flinkDatabaseResourceContainer";
+import type { FlinkDatabaseResourceContainer } from "../models/containers/flinkDatabaseResourceContainer";
+import { FlinkDatabaseContainerLabel } from "../models/containers/flinkDatabaseResourceContainer";
 import { FlinkDatabaseViewProvider } from "../viewProviders/flinkDatabase";
 
 const logger = new Logger("FlinkDatabaseViewCommands");

src/commands/utils/udfRegistration.test.ts

@@ -10,9 +10,10 @@ import { createFlinkUDF } from "../../../tests/unit/testResources/flinkUDF";
 import { TEST_CCLOUD_FLINK_DB_KAFKA_CLUSTER } from "../../../tests/unit/testResources/kafkaCluster";
 import * as emitters from "../../emitters";
 import { type CCloudResourceLoader } from "../../loaders";
-import { FlinkDatabaseResourceContainer } from "../../models/flinkDatabaseResourceContainer";
+import { FlinkDatabaseResourceContainer } from "../../models/containers/flinkDatabaseResourceContainer";
 import type { FlinkUdf } from "../../models/flinkUDF";
-import { CCloudFlinkDbKafkaCluster, CCloudKafkaCluster } from "../../models/kafkaCluster";
+import type { CCloudFlinkDbKafkaCluster } from "../../models/kafkaCluster";
+import { CCloudKafkaCluster } from "../../models/kafkaCluster";
 import * as notifications from "../../notifications";
 import * as kafkaClusterQuickpicks from "../../quickpicks/kafkaClusters";
 import * as jarInspector from "../../utils/jarInspector";

src/models/containers/flinkDatabaseResourceContainer.test.ts

@@ -0,0 +1,33 @@
+import * as assert from "assert";
+import { createFakeFlinkDatabaseResource } from "../../../tests/unit/testResources/flinkDatabaseResource";
+import { ConnectionType } from "../../clients/sidecar";
+import { CCLOUD_CONNECTION_ID } from "../../constants";
+import type { FlinkDatabaseResource } from "../flinkDatabaseResource";
+import { FlinkDatabaseResourceContainer } from "./flinkDatabaseResourceContainer";
+
+describe("models/containers/flinkDatabaseResourceContainer", () => {
+  describe("FlinkDatabaseResourceContainer", () => {
+    describe("constructor", () => {
+      it("should set connectionId to CCLOUD_CONNECTION_ID", () => {
+        const container = new FlinkDatabaseResourceContainer<FlinkDatabaseResource>("Test", []);
+
+        assert.strictEqual(container.connectionId, CCLOUD_CONNECTION_ID);
+      });
+
+      it("should set connectionType to Ccloud", () => {
+        const container = new FlinkDatabaseResourceContainer<FlinkDatabaseResource>("Test", []);
+
+        assert.strictEqual(container.connectionType, ConnectionType.Ccloud);
+      });
+
+      it("should set id to connectionId-label", () => {
+        const label = "Test Database";
+        const container = new FlinkDatabaseResourceContainer(label, [
+          createFakeFlinkDatabaseResource(),
+        ]);
+
+        assert.strictEqual(container.id, `${CCLOUD_CONNECTION_ID}-${label}`);
+      });
+    });
+  });
+});

src/models/containers/flinkDatabaseResourceContainer.ts

@@ -0,0 +1,29 @@
+import type { ThemeIcon } from "vscode";
+import { ConnectionType } from "../../clients/sidecar";
+import { CCLOUD_CONNECTION_ID } from "../../constants";
+import type { FlinkArtifact } from "../flinkArtifact";
+import type { FlinkDatabaseResource } from "../flinkDatabaseResource";
+import { ResourceContainer } from "./resourceContainer";
+
+/** Labels for the top-level containers in the Flink Database view. */
+export enum FlinkDatabaseContainerLabel {
+  RELATIONS = "Tables and Views",
+  ARTIFACTS = "Artifacts",
+  UDFS = "UDFs",
+  AI_CONNECTIONS = "Connections",
+  AI_TOOLS = "AI Tools",
+  AI_MODELS = "AI Models",
+  AI_AGENTS = "AI Agents",
+}
+
+/** A container {@link TreeItem} for resources to display in the Flink Database view. */
+export class FlinkDatabaseResourceContainer<
+  T extends FlinkDatabaseResource | FlinkArtifact,
+> extends ResourceContainer<T> {
+  protected readonly loggerNamePrefix = "FlinkDatabaseResourceContainer";
+
+  constructor(label: string, children: T[], contextValue?: string, icon?: ThemeIcon) {
+    // Flink Database resources are always for the CCLOUD connection
+    super(CCLOUD_CONNECTION_ID, ConnectionType.Ccloud, label, children, contextValue, icon);
+  }
+}

src/models/containers/kafkaClusterResourceContainer.test.ts

@@ -0,0 +1,144 @@
+import * as assert from "assert";
+import type { ThemeIcon } from "vscode";
+import { TEST_DIRECT_CONNECTION_ID } from "../../../tests/unit/testResources/connection";
+import { TEST_CCLOUD_CONSUMER_GROUP } from "../../../tests/unit/testResources/consumerGroup";
+import { ConnectionType } from "../../clients/sidecar";
+import { CCLOUD_CONNECTION_ID } from "../../constants";
+import { IconNames } from "../../icons";
+import { KafkaClusterResourceContainer } from "./kafkaClusterResourceContainer";
+
+const TEST_LABEL = "Test";
+const TEST_CONTEXT_VALUE = "test-container";
+
+describe("models/containers/kafkaClusterResourceContainer", () => {
+  describe("KafkaClusterResourceContainer", () => {
+    describe("constructor", () => {
+      it("should set connectionId from constructor argument", () => {
+        const container = new KafkaClusterResourceContainer(
+          CCLOUD_CONNECTION_ID,
+          ConnectionType.Ccloud,
+          TEST_LABEL,
+        );
+
+        assert.strictEqual(container.connectionId, CCLOUD_CONNECTION_ID);
+      });
+
+      it("should set connectionType from constructor argument", () => {
+        const container = new KafkaClusterResourceContainer(
+          CCLOUD_CONNECTION_ID,
+          ConnectionType.Ccloud,
+          TEST_LABEL,
+        );
+
+        assert.strictEqual(container.connectionType, ConnectionType.Ccloud);
+      });
+
+      it("should set the label from constructor argument", () => {
+        const container = new KafkaClusterResourceContainer(
+          CCLOUD_CONNECTION_ID,
+          ConnectionType.Ccloud,
+          TEST_LABEL,
+        );
+
+        assert.strictEqual(container.label, TEST_LABEL);
+      });
+
+      it("should set contextValue when provided", () => {
+        const container = new KafkaClusterResourceContainer(
+          CCLOUD_CONNECTION_ID,
+          ConnectionType.Ccloud,
+          TEST_LABEL,
+          [],
+          TEST_CONTEXT_VALUE,
+        );
+
+        assert.strictEqual(container.contextValue, TEST_CONTEXT_VALUE);
+      });
+
+      it("should set icon when provided", () => {
+        const container = new KafkaClusterResourceContainer(
+          CCLOUD_CONNECTION_ID,
+          ConnectionType.Ccloud,
+          TEST_LABEL,
+          [],
+          undefined,
+          { id: IconNames.CONSUMER_GROUP } as ThemeIcon,
+        );
+
+        assert.strictEqual((container.iconPath as ThemeIcon).id, IconNames.CONSUMER_GROUP);
+      });
+
+      it("should default to empty children", () => {
+        const container = new KafkaClusterResourceContainer(
+          CCLOUD_CONNECTION_ID,
+          ConnectionType.Ccloud,
+          TEST_LABEL,
+        );
+
+        assert.deepStrictEqual(container.children, []);
+      });
+
+      it("should accept initial children", () => {
+        const children = [TEST_CCLOUD_CONSUMER_GROUP];
+        const container = new KafkaClusterResourceContainer(
+          CCLOUD_CONNECTION_ID,
+          ConnectionType.Ccloud,
+          TEST_LABEL,
+          children,
+        );
+
+        assert.deepStrictEqual(container.children, children);
+      });
+    });
+
+    describe("id derivation", () => {
+      it("should derive id from connectionId and label", () => {
+        const container = new KafkaClusterResourceContainer(
+          CCLOUD_CONNECTION_ID,
+          ConnectionType.Ccloud,
+          "Topics",
+        );
+
+        assert.strictEqual(container.id, `${CCLOUD_CONNECTION_ID}-Topics`);
+      });
+
+      it("should preserve multi-word labels in id", () => {
+        const container = new KafkaClusterResourceContainer(
+          CCLOUD_CONNECTION_ID,
+          ConnectionType.Ccloud,
+          "Consumer Groups",
+        );
+
+        assert.strictEqual(container.id, `${CCLOUD_CONNECTION_ID}-Consumer Groups`);
+      });
+
+      it("should use different ids for different connection types", () => {
+        const ccloudContainer = new KafkaClusterResourceContainer(
+          CCLOUD_CONNECTION_ID,
+          ConnectionType.Ccloud,
+          TEST_LABEL,
+        );
+        const directContainer = new KafkaClusterResourceContainer(
+          TEST_DIRECT_CONNECTION_ID,
+          ConnectionType.Direct,
+          TEST_LABEL,
+        );
+
+        assert.notStrictEqual(ccloudContainer.id, directContainer.id);
+      });
+    });
+
+    describe("loggerName", () => {
+      it("should include label in loggerName", () => {
+        const label = "Test Resources";
+        const container = new KafkaClusterResourceContainer(
+          CCLOUD_CONNECTION_ID,
+          ConnectionType.Ccloud,
+          label,
+        );
+
+        assert.strictEqual(container.loggerName, `KafkaClusterResourceContainer.${label}`);
+      });
+    });
+  });
+});

src/models/containers/kafkaClusterResourceContainer.ts

@@ -0,0 +1,13 @@
+import type { ISearchable } from "../resource";
+import { ResourceContainer } from "./resourceContainer";
+
+/** Labels for the top-level containers in the Topics view. */
+export enum KafkaClusterContainerLabel {
+  TOPICS = "Topics",
+  CONSUMER_GROUPS = "Consumer Groups",
+}
+
+/** A container {@link TreeItem} for resources to display in the Topics view. */
+export class KafkaClusterResourceContainer<T extends ISearchable> extends ResourceContainer<T> {
+  protected readonly loggerNamePrefix = "KafkaClusterResourceContainer";
+}