@platforma-sdk/ui-vue 1.68.8 → 1.70.0

package/src/components/PlDatasetSelector/__tests__/PlDatasetSelector.jsdomtest.ts

@@ -1,6 +1,6 @@
 import { flushPromises, mount } from "@vue/test-utils";
-import type { DatasetOption, PrimaryRef } from "@platforma-sdk/model";
-import { createPlRef, createPrimaryRef } from "@platforma-sdk/model";
+import type { DatasetOption, DatasetSelection } from "@platforma-sdk/model";
+import { createDatasetSelection, createPlRef, createPrimaryRef } from "@platforma-sdk/model";
 import { describe, expect, it } from "vitest";
 import PlDatasetSelector from "../PlDatasetSelector.vue";
 
@@ -9,27 +9,41 @@ const datasetB = createPlRef("2", "out-b", true);
 const filterA1 = createPlRef("1", "filter-a1");
 const filterA2 = createPlRef("1", "filter-a2");
 
+import type { PObjectId } from "@platforma-sdk/model";
+const enrichmentA = "enrichment-a" as PObjectId;
+const enrichmentsA = [
+  { ref: { __isEnrichment: "v1" as const, hit: enrichmentA }, label: "Enrichment A" },
+];
+
 const optionsWithFilters: DatasetOption[] = [
   {
-    label: "Dataset A",
-    ref: datasetA,
+    primary: { label: "Dataset A", ref: datasetA },
     filters: [
       { label: "Top 1000", ref: filterA1 },
       { label: "High quality", ref: filterA2 },
     ],
+    enrichments: enrichmentsA,
   },
   // Dataset B has no filters — filter dropdown must stay hidden.
-  { label: "Dataset B", ref: datasetB },
+  { primary: { label: "Dataset B", ref: datasetB } },
 ];
 
 const datasetC = createPlRef("3", "out-c", true);
 
-const optionsNoFilters: DatasetOption[] = [{ label: "Dataset B", ref: datasetB }];
+const optionsNoFilters: DatasetOption[] = [{ primary: { label: "Dataset B", ref: datasetB } }];
 
 const optionsWithEmptyFilters: DatasetOption[] = [
-  { label: "Dataset C", ref: datasetC, filters: [] },
+  { primary: { label: "Dataset C", ref: datasetC }, filters: [] },
 ];
 
+function selection(
+  ref: typeof datasetA,
+  filter?: typeof filterA1,
+  enrichments?: typeof enrichmentsA,
+): DatasetSelection {
+  return createDatasetSelection(createPrimaryRef(ref, filter), enrichments);
+}
+
 async function pickOption(index: number) {
   const options = [...document.body.querySelectorAll(".dropdown-list-item")] as HTMLElement[];
   options[index].click();
@@ -53,7 +67,7 @@ describe("PlDatasetSelector", () => {
 
   it("shows the filter dropdown when the selected dataset has filters", async () => {
     const wrapper = mount(PlDatasetSelector, {
-      props: { modelValue: createPrimaryRef(datasetA), options: optionsWithFilters },
+      props: { modelValue: selection(datasetA), options: optionsWithFilters },
       attachTo: document.body,
     });
     await flushPromises();
@@ -64,7 +78,7 @@ describe("PlDatasetSelector", () => {
 
   it("hides the filter dropdown when the selected dataset has no filters", async () => {
     const wrapper = mount(PlDatasetSelector, {
-      props: { modelValue: createPrimaryRef(datasetB), options: optionsWithFilters },
+      props: { modelValue: selection(datasetB), options: optionsWithFilters },
       attachTo: document.body,
     });
     await flushPromises();
@@ -73,63 +87,69 @@ describe("PlDatasetSelector", () => {
     wrapper.unmount();
   });
 
-  it("emits PrimaryRef with filter: undefined when dataset changes", async () => {
+  it("emits DatasetSelection bundling primary + enrichments when dataset changes", async () => {
     const wrapper = mount(PlDatasetSelector, {
       props: {
-        modelValue: createPrimaryRef(datasetA, filterA1),
+        modelValue: selection(datasetA, filterA1, enrichmentsA),
         options: optionsWithFilters,
-        "onUpdate:modelValue": (e) => wrapper.setProps({ modelValue: e }),
+        "onUpdate:modelValue": (e: DatasetSelection | undefined) =>
+          wrapper.setProps({ modelValue: e }),
       },
       attachTo: document.body,
     });
     await flushPromises();
 
-    // Open the dataset dropdown (the first input — dataset comes first).
     const inputs = wrapper.findAll("input");
     await inputs[0].trigger("focus");
-
-    // Dataset A is already selected (index 0); pick Dataset B (index 1).
+    // Dataset A is index 0; pick Dataset B (index 1) — has no enrichments.
     await pickOption(1);
 
     const emitted = wrapper.emitted("update:modelValue");
     expect(emitted).toBeDefined();
-    const last = emitted![emitted!.length - 1][0] as PrimaryRef;
-    expect(last).toEqual({ __isPrimaryRef: "v1", column: datasetB });
+    const last = emitted![emitted!.length - 1][0] as DatasetSelection;
+    expect(last).toEqual({
+      __isDatasetSelection: "v1",
+      primary: { __isPrimaryRef: "v1", column: datasetB },
+    });
     wrapper.unmount();
   });
 
-  it("emits PrimaryRef with filter set when a filter is picked", async () => {
+  it("emits DatasetSelection with filter set when a filter is picked", async () => {
     const wrapper = mount(PlDatasetSelector, {
       props: {
-        modelValue: createPrimaryRef(datasetA),
+        modelValue: selection(datasetA, undefined, enrichmentsA),
         options: optionsWithFilters,
-        "onUpdate:modelValue": (e) => wrapper.setProps({ modelValue: e }),
+        "onUpdate:modelValue": (e: DatasetSelection | undefined) =>
+          wrapper.setProps({ modelValue: e }),
       },
       attachTo: document.body,
     });
     await flushPromises();
 
-    // Open the filter dropdown — it's the second input in the component.
     const inputs = wrapper.findAll("input");
     expect(inputs.length).toBe(2);
     await inputs[1].trigger("focus");
-
-    // Options are: [No filter, Top 1000, High quality]. Pick "Top 1000" (index 1).
+    // Options: [No filter, Top 1000, High quality]. Pick "Top 1000".
     await pickOption(1);
 
     const emitted = wrapper.emitted("update:modelValue");
     expect(emitted).toBeDefined();
-    const last = emitted![emitted!.length - 1][0] as PrimaryRef;
-    expect(last).toEqual({ __isPrimaryRef: "v1", column: datasetA, filter: filterA1 });
+    const last = emitted![emitted!.length - 1][0] as DatasetSelection;
+    expect(last).toEqual({
+      __isDatasetSelection: "v1",
+      primary: { __isPrimaryRef: "v1", column: datasetA, filter: filterA1 },
+      enrichments: enrichmentsA,
+    });
     wrapper.unmount();
   });
 
-  it("emits PrimaryRef with filter: undefined when 'No filter' is picked", async () => {
+  it("emits DatasetSelection with no filter key when 'No filter' is picked", async () => {
     const wrapper = mount(PlDatasetSelector, {
       props: {
-        modelValue: createPrimaryRef(datasetA, filterA1),
+        modelValue: selection(datasetA, filterA1, enrichmentsA),
         options: optionsWithFilters,
-        "onUpdate:modelValue": (e) => wrapper.setProps({ modelValue: e }),
+        "onUpdate:modelValue": (e: DatasetSelection | undefined) =>
+          wrapper.setProps({ modelValue: e }),
       },
       attachTo: document.body,
     });
@@ -137,43 +157,20 @@ describe("PlDatasetSelector", () => {
 
     const inputs = wrapper.findAll("input");
     await inputs[1].trigger("focus");
-    // Pick "No filter" (index 0).
-    await pickOption(0);
+    await pickOption(0); // "No filter"
 
     const emitted = wrapper.emitted("update:modelValue");
     expect(emitted).toBeDefined();
-    const last = emitted![emitted!.length - 1][0] as PrimaryRef;
-    expect(last).toEqual({ __isPrimaryRef: "v1", column: datasetA });
-    expect("filter" in last).toBe(false);
-    wrapper.unmount();
-  });
-
-  it("accepts plain PlRef as modelValue for backward compat (filterless dataset)", async () => {
-    const wrapper = mount(PlDatasetSelector, {
-      props: { modelValue: datasetB, options: optionsWithFilters },
-      attachTo: document.body,
-    });
-    await flushPromises();
-
-    expect(wrapper.find(".pl-dataset-selector").element.children.length).toBe(1);
-    wrapper.unmount();
-  });
-
-  it("accepts plain PlRef as modelValue for backward compat (dataset with filters)", async () => {
-    const wrapper = mount(PlDatasetSelector, {
-      props: { modelValue: datasetA, options: optionsWithFilters },
-      attachTo: document.body,
-    });
-    await flushPromises();
-
-    // PlRef matching dataset A — filter dropdown should appear since A has filters.
-    expect(wrapper.find(".pl-dataset-selector").element.children.length).toBe(2);
+    const last = emitted![emitted!.length - 1][0] as DatasetSelection;
+    expect(last.primary).toEqual({ __isPrimaryRef: "v1", column: datasetA });
+    expect("filter" in last.primary).toBe(false);
+    expect(last.enrichments).toEqual(enrichmentsA);
     wrapper.unmount();
   });
 
   it("hides filter dropdown when dataset has filters: [] (empty array)", async () => {
     const wrapper = mount(PlDatasetSelector, {
-      props: { modelValue: createPrimaryRef(datasetC), options: optionsWithEmptyFilters },
+      props: { modelValue: selection(datasetC), options: optionsWithEmptyFilters },
       attachTo: document.body,
     });
     await flushPromises();
@@ -182,25 +179,22 @@ describe("PlDatasetSelector", () => {
     wrapper.unmount();
   });
 
-  it("filter dropdown defaults to 'No filter' when dataset has filters but none selected", async () => {
+  it("does not emit on mount when no filter is selected", async () => {
     const wrapper = mount(PlDatasetSelector, {
       props: {
-        modelValue: createPrimaryRef(datasetA),
+        modelValue: selection(datasetA),
         options: optionsWithFilters,
-        "onUpdate:modelValue": (e) => wrapper.setProps({ modelValue: e }),
+        "onUpdate:modelValue": (e: DatasetSelection | undefined) =>
+          wrapper.setProps({ modelValue: e }),
       },
       attachTo: document.body,
     });
     await flushPromises();
 
-    // No emission on mount — the component does not auto-select a filter.
     expect(wrapper.emitted("update:modelValue")).toBeUndefined();
 
-    // Filter dropdown is visible.
     const inputs = wrapper.findAll("input");
     expect(inputs.length).toBe(2);
-
-    // Open filter dropdown and verify "No filter" is the first option.
     await inputs[1].trigger("focus");
     const items = document.body.querySelectorAll(".dropdown-list-item");
     expect(items.length).toBe(3); // No filter, Top 1000, High quality
@@ -208,12 +202,13 @@ describe("PlDatasetSelector", () => {
     wrapper.unmount();
   });
 
-  it("emits PrimaryRef without filter key when selecting a filterless dataset", async () => {
+  it("emits DatasetSelection without enrichments when the option carries none", async () => {
     const wrapper = mount(PlDatasetSelector, {
       props: {
         modelValue: undefined,
         options: optionsNoFilters,
-        "onUpdate:modelValue": (e) => wrapper.setProps({ modelValue: e }),
+        "onUpdate:modelValue": (e: DatasetSelection | undefined) =>
+          wrapper.setProps({ modelValue: e }),
       },
       attachTo: document.body,
     });
@@ -225,25 +220,28 @@ describe("PlDatasetSelector", () => {
 
     const emitted = wrapper.emitted("update:modelValue");
     expect(emitted).toBeDefined();
-    const last = emitted![emitted!.length - 1][0] as PrimaryRef;
-    expect(last).toEqual({ __isPrimaryRef: "v1", column: datasetB });
-    expect("filter" in last).toBe(false);
+    const last = emitted![emitted!.length - 1][0] as DatasetSelection;
+    expect(last).toEqual({
+      __isDatasetSelection: "v1",
+      primary: { __isPrimaryRef: "v1", column: datasetB },
+    });
+    expect("enrichments" in last).toBe(false);
     wrapper.unmount();
   });
 
   it("emits undefined when cleared via the dataset dropdown", async () => {
     const wrapper = mount(PlDatasetSelector, {
       props: {
-        modelValue: createPrimaryRef(datasetA, filterA1),
+        modelValue: selection(datasetA, filterA1, enrichmentsA),
         options: optionsWithFilters,
         clearable: true,
-        "onUpdate:modelValue": (e) => wrapper.setProps({ modelValue: e }),
+        "onUpdate:modelValue": (e: DatasetSelection | undefined) =>
+          wrapper.setProps({ modelValue: e }),
       },
       attachTo: document.body,
     });
     await flushPromises();
 
-    // PlDropdown's clear button carries the ".clear" class.
     const clearBtn = wrapper.find(".clear");
     expect(clearBtn.exists()).toBe(true);
     await clearBtn.trigger("click");