@malloy-publisher/sdk 0.0.152 → 0.0.155

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/sdk",
    "description": "Malloy Publisher SDK",
-   "version": "0.0.152",
+   "version": "0.0.155",
    "type": "module",
    "main": "dist/index.cjs.js",
    "module": "dist/index.es.js",

package/src/components/Notebook/Notebook.tsx

@@ -3,7 +3,10 @@ import * as Malloy from "@malloydata/malloy-interfaces";
 import { Box, Paper, Stack, Typography } from "@mui/material";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { RawNotebook } from "../../client";
-import { useDimensionalFilterRangeData } from "../../hooks/useDimensionalFilterRangeData";
+import {
+   getDimensionKey,
+   useDimensionalFilterRangeData,
+} from "../../hooks/useDimensionalFilterRangeData";
 import {
    FilterSelection,
    useDimensionFilters,
@@ -121,11 +124,13 @@ export default function Notebook({
       [filterStates, getActiveFilters],
    );
 
-   // Create a map of dimension name -> source name for quick lookup
+   // Create a map of dimension key -> source name for quick lookup
+   // Using composite keys (source:dimensionName) to avoid collisions
    const dimensionToSourceMap = useMemo(() => {
       const map = new Map<string, string>();
       for (const spec of dimensionSpecs) {
-         map.set(spec.dimensionName, spec.source);
+         const key = getDimensionKey(spec);
+         map.set(key, spec.source);
       }
       return map;
    }, [dimensionSpecs]);
@@ -212,16 +217,12 @@ export default function Notebook({
                               new Set<string>();
 
                            // Filter to only include those matching this query's source or joined sources
+                           // FilterSelection now includes source, so we can check directly
                            const filtersForSource = querySourceName
                               ? filtersToApply.filter((filter) => {
-                                   const filterSourceName =
-                                      dimensionToSourceMap.get(
-                                         filter.dimensionName,
-                                      );
-                                   if (!filterSourceName) return false;
                                    return (
-                                      filterSourceName === querySourceName ||
-                                      joinedSources.has(filterSourceName)
+                                      filter.source === querySourceName ||
+                                      joinedSources.has(filter.source)
                                    );
                                 })
                               : [];
@@ -374,10 +375,10 @@ export default function Notebook({
       }
    }, [activeFilters, isExecuting, executeCells]);
 
-   // Handle filter change
+   // Handle filter change using composite key
    const handleFilterChange = useCallback(
-      (dimensionName: string) => (selection: FilterSelection | null) => {
-         updateFilter(dimensionName, selection);
+      (key: string) => (selection: FilterSelection | null) => {
+         updateFilter(key, selection);
       },
       [updateFilter],
    );
@@ -427,11 +428,9 @@ export default function Notebook({
                         }}
                      >
                         {dimensionSpecs.map((spec) => {
-                           const values =
-                              filterValuesData.get(spec.dimensionName) || [];
-                           const filterState = filterStates.get(
-                              spec.dimensionName,
-                           );
+                           const key = getDimensionKey(spec);
+                           const values = filterValuesData.get(key) || [];
+                           const filterState = filterStates.get(key);
                            // Skip Retrieval filters if no retrievalFn provided
                            if (
                               spec.filterType === "Retrieval" &&
@@ -441,14 +440,12 @@ export default function Notebook({
                            }
 
                            return (
-                              <Box key={spec.dimensionName}>
+                              <Box key={key}>
                                  <DimensionFilter
                                     spec={spec}
                                     values={values}
                                     selection={filterState?.selection}
-                                    onChange={handleFilterChange(
-                                       spec.dimensionName,
-                                    )}
+                                    onChange={handleFilterChange(key)}
                                     retrievalFn={retrievalFn}
                                  />
                               </Box>

package/src/components/filter/DimensionFilter.tsx

@@ -265,6 +265,7 @@ export function DimensionFilter({
       if (value1) {
          onChange({
             dimensionName: spec.dimensionName,
+            source: spec.source,
             matchType: newMatchType,
             value: value1,
             ...(requiresTwoValues(newMatchType) && value2 && { value2 }),
@@ -294,6 +295,7 @@ export function DimensionFilter({
       ) {
          onChange({
             dimensionName: spec.dimensionName,
+            source: spec.source,
             matchType,
             value: newValue1,
             ...(needsTwoValues && newValue2 && { value2: newValue2 }),

package/src/components/filter/utils.ts

@@ -263,16 +263,20 @@ export function extractDimensionSpecs(
  */
 export function generateFilterClause(
    activeFilters: FilterSelection[],
-   dimensionToSourceMap: Map<string, string>,
+   _dimensionToSourceMap: Map<string, string>,
    querySourceName: string | null,
 ): string {
    if (activeFilters.length === 0) return "";
 
    const conditions = activeFilters
       .map((selection) => {
-         const { dimensionName, matchType, value, value2 } = selection;
-         // Get the source name for this dimension
-         const filterSourceName = dimensionToSourceMap.get(dimensionName);
+         const {
+            dimensionName,
+            source: filterSourceName,
+            matchType,
+            value,
+            value2,
+         } = selection;
          // Only use source.dimension format if the filter's source is different from the query's source
          // (i.e., it's a joined source, not the main source)
          const needsSourcePrefix =

package/src/hooks/index.ts

@@ -22,6 +22,8 @@ export {
 
 export {
    useDimensionalFilterRangeData,
+   getDimensionKey,
+   makeDimensionKey,
    type DimensionalFilterRangeDataResult,
    type DimensionSpec,
    type DimensionValue,

package/src/hooks/useDimensionFilters.ts

@@ -1,5 +1,8 @@
 import { useCallback, useEffect, useState } from "react";
-import { DimensionSpec } from "./useDimensionalFilterRangeData";
+import {
+   DimensionSpec,
+   getDimensionKey,
+} from "./useDimensionalFilterRangeData";
 
 /**
  * Match types for filtering dimensions
@@ -29,6 +32,8 @@ export type FilterValue = FilterValuePrimitive | FilterValuePrimitive[];
  */
 export interface FilterSelection {
    dimensionName: string;
+   /** Source name - required to uniquely identify filters when same dimension name exists in multiple sources */
+   source: string;
    matchType: MatchType;
    value: FilterValue;
    value2?: FilterValuePrimitive; // For "Between" match type
@@ -54,15 +59,12 @@ export interface UseDimensionFiltersParams {
  * Result from the useDimensionFilters hook
  */
 export interface UseDimensionFiltersResult {
-   /** Current filter states */
+   /** Current filter states, keyed by composite key (source:dimensionName) */
    filterStates: Map<string, DimensionFilterState>;
-   /** Update a filter selection */
-   updateFilter: (
-      dimensionName: string,
-      selection: FilterSelection | null,
-   ) => void;
-   /** Clear a specific filter */
-   clearFilter: (dimensionName: string) => void;
+   /** Update a filter selection using composite key */
+   updateFilter: (key: string, selection: FilterSelection | null) => void;
+   /** Clear a specific filter using composite key */
+   clearFilter: (key: string) => void;
    /** Clear all filters */
    clearAllFilters: () => void;
    /** Get active filters (with selections) */
@@ -207,13 +209,14 @@ export function useDimensionFilters(
 ): UseDimensionFiltersResult {
    const { dimensionSpecs } = params;
 
-   // Initialize filter states
+   // Initialize filter states using composite keys (source:dimensionName)
    const [filterStates, setFilterStates] = useState<
       Map<string, DimensionFilterState>
    >(() => {
       const initialStates = new Map<string, DimensionFilterState>();
       dimensionSpecs.forEach((spec) => {
-         initialStates.set(spec.dimensionName, {
+         const key = getDimensionKey(spec);
+         initialStates.set(key, {
             spec,
             selection: null,
          });
@@ -227,9 +230,10 @@ export function useDimensionFilters(
          const newStates = new Map<string, DimensionFilterState>();
 
          dimensionSpecs.forEach((spec) => {
+            const key = getDimensionKey(spec);
             // Preserve existing selection if the dimension already exists
-            const existingState = prevStates.get(spec.dimensionName);
-            newStates.set(spec.dimensionName, {
+            const existingState = prevStates.get(key);
+            newStates.set(key, {
                spec,
                selection: existingState?.selection ?? null,
             });
@@ -239,15 +243,15 @@ export function useDimensionFilters(
       });
    }, [dimensionSpecs]);
 
-   // Update a filter selection
+   // Update a filter selection using composite key
    const updateFilter = useCallback(
-      (dimensionName: string, selection: FilterSelection | null) => {
+      (key: string, selection: FilterSelection | null) => {
          setFilterStates((prevStates) => {
             const newStates = new Map(prevStates);
-            const existingState = newStates.get(dimensionName);
+            const existingState = newStates.get(key);
 
             if (existingState) {
-               newStates.set(dimensionName, {
+               newStates.set(key, {
                   ...existingState,
                   selection,
                });
@@ -259,10 +263,10 @@ export function useDimensionFilters(
       [],
    );
 
-   // Clear a specific filter
+   // Clear a specific filter using composite key
    const clearFilter = useCallback(
-      (dimensionName: string) => {
-         updateFilter(dimensionName, null);
+      (key: string) => {
+         updateFilter(key, null);
       },
       [updateFilter],
    );

package/src/hooks/useDimensionalFilterRangeData.ts

@@ -34,6 +34,24 @@ export interface DimensionSpec {
    values?: string[];
 }
 
+/**
+ * Generates a unique key from source and dimension name strings.
+ * This prevents collisions when the same dimension name exists in different sources.
+ */
+export function makeDimensionKey(
+   source: string,
+   dimensionName: string,
+): string {
+   return `${source}:${dimensionName}`;
+}
+
+/**
+ * Generates a unique key for a dimension by combining source and dimension name.
+ */
+export function getDimensionKey(spec: DimensionSpec): string {
+   return makeDimensionKey(spec.source, spec.dimensionName);
+}
+
 /**
  * Value information for a dimension
  */
@@ -43,7 +61,7 @@ export interface DimensionValue {
 }
 
 /**
- * Result type mapping dimension names to their values
+ * Result type mapping dimension keys (source:dimensionName) to their values
  */
 export type DimensionValues = Map<string, DimensionValue[]>;
 
@@ -236,13 +254,7 @@ function buildDimensionalIndexQuery(
 
    // Filter activeFilters to only include those for this source
    const filtersForSource =
-      activeFilters?.filter((f) => {
-         // Find the spec for this filter's dimension
-         const spec = dimensionSpecs.find(
-            (s) => s.dimensionName === f.dimensionName,
-         );
-         return spec?.source === source;
-      }) || [];
+      activeFilters?.filter((f) => f.source === source) || [];
 
    // Generate WHERE conditions from active filters (without 'where' keyword)
    const whereConditions =
@@ -332,9 +344,10 @@ function parseIndexQueryResult(
 ): { values: DimensionValues; noRowsMatchedFilter: boolean } {
    const dimensionValues = new Map<string, DimensionValue[]>();
 
-   // Initialize empty arrays for all dimensions
+   // Initialize empty arrays for all dimensions using composite keys
    for (const spec of dimensionSpecs) {
-      dimensionValues.set(spec.dimensionName, []);
+      const key = getDimensionKey(spec);
+      dimensionValues.set(key, []);
    }
 
    // Parse the result JSON if it's a string
@@ -460,6 +473,8 @@ function parseIndexQueryResult(
          continue;
       }
 
+      const specKey = getDimensionKey(spec);
+
       if (spec.filterType === "Star") {
          // For Star filter, we want all distinct values with their weights
          // String fields return individual fieldValue entries
@@ -474,7 +489,7 @@ function parseIndexQueryResult(
                   (b.count ?? 0) - (a.count ?? 0),
             ); // Sort by count descending
 
-         dimensionValues.set(spec.dimensionName, values);
+         dimensionValues.set(specKey, values);
       } else if (spec.filterType === "MinMax") {
          // For MinMax filter, numeric fields return a range in fieldValue
          // Format is typically "min to max"
@@ -504,7 +519,7 @@ function parseIndexQueryResult(
                   { value: parseFloat(rangeParts[0]) },
                   { value: parseFloat(rangeParts[1]) },
                ];
-               dimensionValues.set(spec.dimensionName, values);
+               dimensionValues.set(specKey, values);
             } else {
                console.warn(
                   `Could not parse numeric range for ${spec.dimensionName}: ${rangeString}`,
@@ -546,7 +561,7 @@ function parseIndexQueryResult(
                   { value: new Date(rangeParts[0].trim()) },
                   { value: new Date(rangeParts[1].trim()) },
                ];
-               dimensionValues.set(spec.dimensionName, values);
+               dimensionValues.set(specKey, values);
             } else {
                console.warn(
                   `Could not parse date range for ${spec.dimensionName}: ${rangeString}`,
@@ -675,10 +690,11 @@ export function useDimensionalFilterRangeData(
       ],
       queryFn: async () => {
          if (!shouldExecuteQuery) {
-            // Return empty map if no query needed
+            // Return empty map if no query needed (using composite keys)
             const emptyMap = new Map<string, DimensionValue[]>();
             for (const spec of dimensionSpecs) {
-               emptyMap.set(spec.dimensionName, []);
+               const key = getDimensionKey(spec);
+               emptyMap.set(key, []);
             }
             return { values: emptyMap, noRowsMatchedFilter: false };
          }
@@ -728,15 +744,16 @@ export function useDimensionalFilterRangeData(
    const mergedData = useMemo(() => {
       const result = new Map<string, DimensionValue[]>();
 
-      // Initialize with static values or empty arrays
+      // Initialize with static values or empty arrays using composite keys
       for (const spec of dimensionSpecs) {
+         const key = getDimensionKey(spec);
          if (spec.values) {
             result.set(
-               spec.dimensionName,
+               key,
                spec.values.map((v) => ({ value: v })),
             );
          } else {
-            result.set(spec.dimensionName, []);
+            result.set(key, []);
          }
       }