@malloy-publisher/sdk 0.0.181 → 0.0.183-dev

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/sdk",
    "description": "Malloy Publisher SDK",
-   "version": "0.0.181",
+   "version": "0.0.183-dev",
    "type": "module",
    "main": "dist/index.cjs.js",
    "module": "dist/index.es.js",
@@ -47,9 +47,7 @@
    },
    "style": "./dist/malloy-explorer.css",
    "sideEffects": [
-      "**/*.css",
-      "./src/index.ts",
-      "./dist/index.*.js"
+      "**/*.css"
    ],
    "repository": {
       "type": "git",
@@ -72,10 +70,10 @@
       "react-dom": ">=19.1.0",
       "react-router-dom": ">=7.6.2",
       "@tanstack/react-query": ">=5.59.16",
-      "@malloydata/malloy-explorer": "^0.0.374",
-      "@malloydata/malloy-interfaces": "^0.0.374",
-      "@malloydata/malloy-query-builder": "^0.0.374",
-      "@malloydata/render": "^0.0.374",
+      "@malloydata/malloy-explorer": ">=0.0.338-dev260215172810",
+      "@malloydata/malloy-interfaces": ">=0.0.374",
+      "@malloydata/malloy-query-builder": ">=0.0.374",
+      "@malloydata/render": ">=0.0.374",
       "@mui/icons-material": ">=7.1.1",
       "@mui/x-date-pickers": ">=7.1.1",
       "@mui/material": ">=7.1.1",

package/src/components/Notebook/Notebook.tsx

@@ -2,7 +2,7 @@ import "@malloydata/malloy-explorer/styles.css";
 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 { RawNotebook, Source } from "../../client";
 import {
    getDimensionKey,
    useDimensionalFilterRangeData,
@@ -16,10 +16,6 @@ import { ApiErrorDisplay } from "../ApiErrorDisplay";
 import { DimensionFilter, RetrievalFunction } from "../filter/DimensionFilter";
 import {
    extractDimensionSpecs,
-   extractSourceFromQuery,
-   generateFilterClause,
-   getJoinedSources,
-   injectWhereClause,
    parseAllSourceInfos,
    parseNotebookFilterAnnotation,
 } from "../filter/utils";
@@ -81,7 +77,7 @@ export default function Notebook({
    const [isExecuting, setIsExecuting] = useState(false);
    const [executionError, setExecutionError] = useState<Error | null>(null);
 
-   // Parse filter configuration from notebook annotations
+   // Parse filter configuration from notebook annotations (legacy ##(filters) approach)
    const filterConfig = useMemo(() => {
       if (!notebook) return null;
       return parseNotebookFilterAnnotation(notebook.annotations);
@@ -99,16 +95,112 @@ export default function Notebook({
    );
    const modelPath = sourceData?.modelPath ?? null;
 
+   // Extract server-side filter definitions from notebook sources
+   // These come from #(filter) annotations parsed by the server
+   const serverFilters = useMemo(() => {
+      const result = new Map<string, Source["filters"]>();
+      if (!notebook?.sources) return result;
+      for (const source of notebook.sources as Source[]) {
+         if (source.name && source.filters && source.filters.length > 0) {
+            // Exclude implicit filters from the UI
+            const visibleFilters = source.filters.filter((f) => !f.implicit);
+            if (visibleFilters.length > 0) {
+               result.set(source.name, visibleFilters);
+            }
+         }
+      }
+      return result;
+   }, [notebook]);
+
+   // Determine if we're using server-driven filters (#(filter)) or legacy (##(filters))
+   const useServerFilters = serverFilters.size > 0;
+
    // Build dimension specs from filter config and source info map
    // Each spec includes source and model for proper query routing
    const dimensionSpecs = useMemo(() => {
+      if (useServerFilters && modelPath) {
+         // Server-driven: build specs from #(filter) metadata
+         const specs: import("../../hooks/useDimensionalFilterRangeData").DimensionSpec[] =
+            [];
+         for (const [sourceName, filters] of serverFilters) {
+            for (const filter of filters ?? []) {
+               if (!filter.dimension || !filter.type) continue;
+
+               // Choose widget type based on the dimension's data type first,
+               // then fall back to the annotation's comparator type
+               type FT =
+                  import("../../hooks/useDimensionalFilterRangeData").FilterType;
+               let filterType: FT;
+               const dimType = filter.dimensionType;
+               if (dimType === "boolean") {
+                  filterType = "Boolean";
+               } else if (
+                  dimType === "date" ||
+                  dimType === "timestamp" ||
+                  dimType === "timestamptz"
+               ) {
+                  filterType = "DateMinMax";
+               } else if (dimType === "number") {
+                  filterType =
+                     filter.type === "equal" || filter.type === "in"
+                        ? "Star"
+                        : "MinMax";
+               } else {
+                  const filterTypeMap: Record<string, FT> = {
+                     equal: "Star",
+                     in: "Star",
+                     like: "Star",
+                     greater_than: "MinMax",
+                     less_than: "MinMax",
+                  };
+                  filterType = filterTypeMap[filter.type] ?? "Star";
+               }
+
+               // Derive the match type from the #(filter) annotation type so
+               // the UI never needs to show a match-type dropdown.
+               type MT = import("../../hooks/useDimensionFilters").MatchType;
+               const matchTypeMap: Record<string, MT> = {
+                  equal: "Equals",
+                  in: "Equals",
+                  like: "Contains",
+                  greater_than:
+                     filterType === "DateMinMax" ? "After" : "Greater Than",
+                  less_than:
+                     filterType === "DateMinMax" ? "Before" : "Less Than",
+               };
+               const defaultMatchType: MT | undefined =
+                  matchTypeMap[filter.type!];
+
+               const filterLabel =
+                  filter.name !== filter.dimension ? filter.name : undefined;
+               specs.push({
+                  source: sourceName,
+                  model: modelPath,
+                  dimensionName: filter.dimension!,
+                  filterType,
+                  label: filterLabel,
+                  filterName: filter.name ?? filter.dimension!,
+                  defaultMatchType,
+                  required: filter.required ?? false,
+               });
+            }
+         }
+         return specs;
+      }
+      // Legacy: use ##(filters) + #(filter) annotation approach
       if (!filterConfig || sourceInfoMap.size === 0 || !modelPath) return [];
       return extractDimensionSpecs(
          sourceInfoMap,
          filterConfig.filters,
          modelPath,
       );
-   }, [filterConfig, sourceInfoMap, modelPath]);
+   }, [
+      useServerFilters,
+      serverFilters,
+      filterConfig,
+      sourceInfoMap,
+      modelPath,
+   ]);
 
    // Initialize dimension filters hook
    const { filterStates, updateFilter, getActiveFilters } = useDimensionFilters(
@@ -124,9 +216,8 @@ export default function Notebook({
       [filterStates, getActiveFilters],
    );
 
-   // Create a map of dimension key -> source name for quick lookup
-   // Using composite keys (source:dimensionName) to avoid collisions
-   const dimensionToSourceMap = useMemo(() => {
+   // Create a map of dimension key -> source name for quick lookup (used by filter UI)
+   const _dimensionToSourceMap = useMemo(() => {
       const map = new Map<string, string>();
       for (const spec of dimensionSpecs) {
          const key = getDimensionKey(spec);
@@ -135,28 +226,55 @@ export default function Notebook({
       return map;
    }, [dimensionSpecs]);
 
-   // Create a map of source name -> set of joined source names
-   const sourceJoinsMap = useMemo(() => {
-      const map = new Map<string, Set<string>>();
-      for (const [sourceName, sourceInfo] of sourceInfoMap) {
-         map.set(sourceName, getJoinedSources(sourceInfo));
-      }
-      return map;
-   }, [sourceInfoMap]);
-
-   // Fetch filter range data when we have dimension specs
-   // The hook now handles multiple source/model combos internally
+   // Fetch filter range data when we have dimension specs.
+   // Do NOT pass activeFilters here — the index query should return all
+   // possible values for each dimension, not just those matching the
+   // current selection. Otherwise selecting "FORD" would hide every other
+   // manufacturer from the dropdown.
    const { data: filterValuesData } = useDimensionalFilterRangeData({
       project: projectName,
       package: packageName,
       dimensionSpecs,
       versionId,
       enabled: dimensionSpecs.length > 0,
-      activeFilters,
    });
 
+   /**
+    * Convert active FilterSelections into a flat { filterName: value } map
+    * suitable for the server's filter_params parameter.
+    * Uses filterName from the selection (propagated from the spec) as the
+    * API param key, falling back to dimensionName.
+    */
+   const buildFilterParams = useCallback(
+      (filtersToApply: FilterSelection[]): string | undefined => {
+         if (filtersToApply.length === 0) return undefined;
+
+         const toParamString = (v: unknown): string => {
+            if (v instanceof Date) {
+               return v.toISOString().slice(0, 10);
+            }
+            return String(v);
+         };
+
+         const params: { [key: string]: string | string[] } = {};
+         for (const f of filtersToApply) {
+            const paramName = f.filterName ?? f.dimensionName;
+            const val = f.value;
+            if (Array.isArray(val)) {
+               params[paramName] = val.map(toParamString);
+            } else if (val !== undefined && val !== null) {
+               params[paramName] = toParamString(val);
+            }
+         }
+         return Object.keys(params).length > 0
+            ? JSON.stringify(params)
+            : undefined;
+      },
+      [],
+   );
+
    // Unified cell execution function
-   // Executes all notebook cells, optionally applying filters to query cells
+   // Executes all notebook cells, passing server-side filter params when available
    // Runs up to 4 requests in parallel for better performance
    const executeCells = useCallback(
       async (filtersToApply: FilterSelection[] = []) => {
@@ -176,6 +294,10 @@ export default function Notebook({
          setIsExecuting(true);
          setExecutionError(null);
 
+         const filterParams = useServerFilters
+            ? buildFilterParams(filtersToApply)
+            : undefined;
+
          try {
             // Build execution tasks for code cells
             const executionTasks: Array<() => Promise<void>> = [];
@@ -186,95 +308,30 @@ export default function Notebook({
                // Markdown cells don't need execution
                if (rawCell.type === "markdown") continue;
 
-               // Execute code cells
-               const cellText = rawCell.text || "";
-               const hasQuery =
-                  cellText.includes("run:") ||
-                  cellText.includes("->") ||
-                  /^\s*(run|query)\s*:/m.test(cellText);
-
                // Capture cell index for closure
                const cellIndex = i;
 
                const executeCell = async () => {
                   try {
-                     let result: string | undefined;
-                     let newSources: string[] | undefined;
-
-                     if (hasQuery && modelPath && filtersToApply.length > 0) {
-                        // Query cell - use models API with optional filters
-                        let queryToExecute = cellText;
-
-                        // Apply filters if any match this query's source
-                        if (filtersToApply.length > 0) {
-                           const querySourceName =
-                              extractSourceFromQuery(cellText);
-
-                           // Get the set of joined sources for this query's source
-                           const joinedSources =
-                              (querySourceName &&
-                                 sourceJoinsMap.get(querySourceName)) ||
-                              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) => {
-                                   return (
-                                      filter.source === querySourceName ||
-                                      joinedSources.has(filter.source)
-                                   );
-                                })
-                              : [];
-
-                           if (filtersForSource.length > 0) {
-                              const filterClause = generateFilterClause(
-                                 filtersForSource,
-                                 dimensionToSourceMap,
-                                 querySourceName,
-                              );
-                              if (filterClause) {
-                                 queryToExecute = injectWhereClause(
-                                    cellText,
-                                    filterClause,
-                                 );
-                              }
-                           }
-                        }
-
-                        // Execute using models API
-                        const response =
-                           await apiClients.models.executeQueryModel(
-                              projectName,
-                              packageName,
-                              modelPath,
-                              {
-                                 query: queryToExecute,
-                                 versionId,
-                              },
-                           );
-                        result = response.data.result;
-                     } else {
-                        // Non-query code cell (or no filters applied) - use notebook cell execution API
-                        const response =
-                           await apiClients.notebooks.executeNotebookCell(
-                              projectName,
-                              packageName,
-                              notebookPath,
-                              cellIndex,
-                              versionId,
-                           );
-
-                        const executedCell = response.data;
-                        result = executedCell.result;
-                        newSources =
-                           rawCell.newSources || executedCell.newSources;
-                     }
+                     // Use notebook cell execution API with optional filter_params
+                     const response =
+                        await apiClients.notebooks.executeNotebookCell(
+                           projectName,
+                           packageName,
+                           notebookPath,
+                           cellIndex,
+                           versionId,
+                           filterParams,
+                        );
+
+                     const executedCell = response.data;
+                     const result = executedCell.result;
+                     const newSources =
+                        rawCell.newSources || executedCell.newSources;
 
                      // Update state incrementally
                      setEnhancedCells((prev) => {
                         const next = [...prev];
-                        // Ensure we have a cell to update (in case state was reset externally, though unlikely)
                         if (!next[cellIndex]) {
                            next[cellIndex] = { ...rawCell };
                         }
@@ -290,7 +347,6 @@ export default function Notebook({
                         `Error executing cell ${cellIndex}:`,
                         cellError,
                      );
-                     // Don't update result on error, leave as is (undefined)
                   }
                };
 
@@ -323,14 +379,12 @@ export default function Notebook({
       [
          isSuccess,
          notebook,
-         modelPath,
-         dimensionToSourceMap,
-         sourceJoinsMap,
+         useServerFilters,
+         buildFilterParams,
          projectName,
          packageName,
          notebookPath,
          versionId,
-         apiClients.models,
          apiClients.notebooks,
       ],
    );

package/src/components/ServerProvider.tsx

@@ -21,6 +21,14 @@ import {
 import { Configuration } from "../client/configuration";
 import { globalQueryClient } from "../utils/queryClient";
 
+// There's a bug in the OpenAPI generator that causes it to ignore baseURL in
+// the axios request if axios.defaults.baseURL is not set. The per-instance
+// baseURL on the custom axios instance below is the real value we use; this
+// sentinel exists only to satisfy the generated client's code path.
+if (!axios.defaults.baseURL) {
+   axios.defaults.baseURL = "IfYouAreSeeingThis_baseURL_IsNotSet";
+}
+
 export interface ServerContextValue {
    server: string;
    getAccessToken?: () => Promise<string>;

package/src/components/filter/DimensionFilter.tsx

@@ -115,9 +115,9 @@ export function DimensionFilter({
    onChange,
    retrievalFn,
 }: DimensionFilterProps) {
-   // Default to "Between" for date filters, otherwise use first available match type
    const getDefaultMatchType = () => {
       if (selection?.matchType) return selection.matchType;
+      if (spec.defaultMatchType) return spec.defaultMatchType;
       if (spec.filterType === "DateMinMax") return "Between";
       return getAvailableMatchTypes(spec.filterType)[0] || "Equals";
    };
@@ -203,11 +203,11 @@ export function DimensionFilter({
          // Clear internal state when selection is cleared externally
          setValue1("");
          setValue2("");
-         // Reset to default match type (Between for dates, first available for others)
          setMatchType(
-            spec.filterType === "DateMinMax"
-               ? "Between"
-               : getAvailableMatchTypes(spec.filterType)[0] || "Equals",
+            spec.defaultMatchType ??
+               (spec.filterType === "DateMinMax"
+                  ? "Between"
+                  : getAvailableMatchTypes(spec.filterType)[0] || "Equals"),
          );
       } else if (selection) {
          // Update internal state when selection changes externally
@@ -216,7 +216,7 @@ export function DimensionFilter({
          setValue1(selection.value ?? "");
          setValue2(selection.value2 ?? "");
       }
-   }, [selection, spec.filterType]);
+   }, [selection, spec.filterType, spec.defaultMatchType]);
 
    const availableMatchTypes = getAvailableMatchTypes(spec.filterType);
    const isDate = isDateFilter(spec.filterType);
@@ -266,6 +266,7 @@ export function DimensionFilter({
          onChange({
             dimensionName: spec.dimensionName,
             source: spec.source,
+            filterName: spec.filterName,
             matchType: newMatchType,
             value: value1,
             ...(requiresTwoValues(newMatchType) && value2 && { value2 }),
@@ -296,6 +297,7 @@ export function DimensionFilter({
          onChange({
             dimensionName: spec.dimensionName,
             source: spec.source,
+            filterName: spec.filterName,
             matchType,
             value: newValue1,
             ...(needsTwoValues && newValue2 && { value2: newValue2 }),
@@ -326,9 +328,8 @@ export function DimensionFilter({
             "& .MuiAutocomplete-root .MuiInputBase-root": {
                padding: "5px 10px",
                minHeight: "29.5px",
-               maxHeight: "29.5px",
                boxSizing: "border-box",
-               overflow: "hidden",
+               flexWrap: "wrap",
             },
             "& .MuiChip-root": { height: "16px", margin: "0 2px 0 0" },
             "& .MuiChip-label": { fontSize: "0.7rem", padding: "0 6px" },
@@ -354,38 +355,62 @@ export function DimensionFilter({
             "& .MuiSvgIcon-root": { fontSize: "1.25rem" },
          }}
       >
-         {/* Dimension Label/Name */}
-         <Box sx={{ fontWeight: 600 }}>{spec.label ?? spec.dimensionName}</Box>
-
-         {/* Match Type Selector */}
-         {spec.filterType !== "Boolean" && (
-            <FormControl size="small" fullWidth>
-               <InputLabel>Match Type</InputLabel>
-               <Select
-                  value={matchType}
-                  label="Match Type"
-                  onChange={handleMatchTypeChange}
-                  disabled={availableMatchTypes.length === 1}
-                  MenuProps={{
-                     PaperProps: {
-                        sx: {
-                           "& .MuiMenuItem-root": {
-                              fontSize: "0.75rem",
-                              minHeight: "auto",
-                              padding: "4px 10px",
-                           },
-                        },
-                     },
+         {/* Dimension Label/Name — red when required and not yet set */}
+         <Box
+            sx={{
+               fontWeight: 600,
+               color:
+                  spec.required && !selection ? "error.main" : "text.primary",
+            }}
+         >
+            {spec.label ?? spec.dimensionName}
+            {spec.required && (
+               <Box
+                  component="span"
+                  sx={{
+                     color: !selection ? "error.main" : "text.secondary",
+                     fontWeight: 400,
+                     fontSize: "0.7rem",
+                     ml: 0.5,
                   }}
                >
-                  {availableMatchTypes.map((type) => (
-                     <MenuItem key={type} value={type}>
-                        {type}
-                     </MenuItem>
-                  ))}
-               </Select>
-            </FormControl>
-         )}
+                  (required)
+               </Box>
+            )}
+         </Box>
+
+         {/* Match Type Selector — hidden when the filter annotation already
+             determines the match type (defaultMatchType is set). Only shown
+             for legacy/untyped filters where the user needs to choose. */}
+         {spec.filterType !== "Boolean" &&
+            !spec.defaultMatchType &&
+            availableMatchTypes.length > 1 && (
+               <FormControl size="small" fullWidth>
+                  <InputLabel>Match Type</InputLabel>
+                  <Select
+                     value={matchType}
+                     label="Match Type"
+                     onChange={handleMatchTypeChange}
+                     MenuProps={{
+                        PaperProps: {
+                           sx: {
+                              "& .MuiMenuItem-root": {
+                                 fontSize: "0.75rem",
+                                 minHeight: "auto",
+                                 padding: "4px 10px",
+                              },
+                           },
+                        },
+                     }}
+                  >
+                     {availableMatchTypes.map((type) => (
+                        <MenuItem key={type} value={type}>
+                           {type}
+                        </MenuItem>
+                     ))}
+                  </Select>
+               </FormControl>
+            )}
 
          {/* Value Input - varies by filter type */}
          {spec.filterType === "Star" && matchType === "Equals" && (
@@ -455,7 +480,11 @@ export function DimensionFilter({
                size="small"
                label="Search Text"
                value={value1}
-               onChange={(e) => handleValueChange(e.target.value)}
+               onChange={(e) => setValue1(e.target.value)}
+               onBlur={() => handleValueChange(value1)}
+               onKeyDown={(e) => {
+                  if (e.key === "Enter") handleValueChange(value1);
+               }}
                placeholder="Enter text to search..."
                fullWidth
             />