@pythia-software/query-table-react 0.7.1 → 0.8.0

package/dist/index.d.ts

@@ -1,7 +1,19 @@
-import { QueryState, GroupedRow, GroupingModel, FieldSchema, GroupingView, SummaryOp, RepresentativeRow, SummaryColumn, SelectColumn, PropertyViewState, SavedPropertyView, PropertyViewStorage, QueryLink, QuerySnapshot, ItemPropertyMode, ItemPageOptions, ItemDetailMode, ItemDetailsState, RelationshipAdapter, RowId, FormulaNode, FormulaValue, FormulaResult, ComputedColumn, FieldDef, ComputedColumnDraft, FormulaPlan, ColumnPreview, SavedQuery, StorageAdapter, AggOp, AggregationClause, AggregationResult, WhereClause, DistinctValuesResult, FieldStats, OrderByClause, Transport, ComputedColumnStore, ComputedExecution, QueryLinkOptions, ObjectReference, ResolvedObjectReference } from '@pythia-software/query-table-core';
+import { FieldSchema, WhereClause, QueryState, GroupedRow, GroupingModel, GroupingView, SummaryOp, RepresentativeRow, SummaryColumn, SelectColumn, PropertyViewState, SavedPropertyView, PropertyViewStorage, QueryLink, QuerySnapshot, ItemPropertyMode, ItemPageOptions, ItemDetailMode, ItemDetailsState, RelationshipAdapter, RowId, FormulaNode, FormulaValue, FormulaResult, ComputedColumn, FieldDef, ComputedColumnDraft, FormulaPlan, ColumnPreview, SavedQuery, StorageAdapter, AggOp, AggregationClause, AggregationResult, DistinctValuesResult, FieldStats, OrderByClause, Transport, ComputedColumnStore, ComputedExecution, QueryLinkOptions, ObjectReference, ResolvedObjectReference } from '@pythia-software/query-table-core';
 
 /** Filter controls for either the result query or grouping's source query. */
 type QueryFilterApi<Row> = Pick<QueryTableApi<Row>, "query" | "setQuery" | "loading" | "addFilter" | "updateFilter" | "removeFilter" | "clearFilters" | "updatePredicate" | "removePredicate" | "negatePredicate" | "reorderFilters" | "mergeFilters" | "filterValues" | "fieldStats">;
+/** Bind filter intents to a query stage, including the source WHERE of grouping. */
+declare function useQueryFilters<Row>(schema: FieldSchema<Row>, setQuery: QueryTableApi<Row>["setQuery"]): {
+    addFilter: (clause: WhereClause) => void;
+    updateFilter: (index: number, clause: WhereClause) => void;
+    removeFilter: (index: number) => void;
+    clearFilters: () => void;
+    updatePredicate: (termIndex: number, predIndex: number, clause: WhereClause) => void;
+    removePredicate: (termIndex: number, predIndex: number) => void;
+    negatePredicate: (termIndex: number, predIndex: number) => void;
+    reorderFilters: (fromIndex: number, toIndex: number) => void;
+    mergeFilters: (sourceIndex: number, targetIndex: number) => void;
+};
 
 /** Source-stage controls. Rows/columns/metrics remain on the active result API. */
 type GroupingSourceApi<Row> = QueryFilterApi<Row> & Pick<QueryTableApi<Row>, "itemDetails" | "rowId"> & {
@@ -21,6 +33,10 @@ interface GroupingApi<Row> {
     grouped: QueryTableApi<Row>;
     schema: FieldSchema<Row>;
     view: GroupingView;
+    /** Problems with link columns. They never block the grouped table: an
+     * invalid link renders as plain text. Unregistered host targets are
+     * reported when rendering. */
+    diagnostics: string[];
     inputs: Row[];
     notice: string;
     setNotice: (notice: string) => void;
@@ -463,4 +479,4 @@ declare function useObjectReferences(references: ObjectReference[], adapter?: Re
     error: Error | null;
 };
 
-export { type AggregationPatch, type AggregationsApi, type AggregationsApiState, type AutoRefreshApi, type AutoRefreshConfig, type AutoRefreshStatus, type ColumnDragApi, type ComputedColumnsApi, type FormulaWorkerFactory, type GroupingApi, type GroupingSourceApi, type ItemDetailRecord, type ItemDetailsApi, type ItemDetailsOptions, type PropertyViewApi, type QueryFilterApi, type QueryLinksApi, type QueryTableApi, type RequestActivityApi, type RequestActivityEntry, type SavedQueriesApi, type SelectApi, type SelectionApi, type UsePropertyViewOptions, type UseQueryTableOptions, createFormulaWorker, evaluateFormulaRows, useAggregations, useColumnDrag, useObjectReferences, usePropertyView, useQueryTable, useSavedQueries, useSelect, useSelection };
+export { type AggregationPatch, type AggregationsApi, type AggregationsApiState, type AutoRefreshApi, type AutoRefreshConfig, type AutoRefreshStatus, type ColumnDragApi, type ComputedColumnsApi, type FormulaWorkerFactory, type GroupingApi, type GroupingSourceApi, type ItemDetailRecord, type ItemDetailsApi, type ItemDetailsOptions, type PropertyViewApi, type QueryFilterApi, type QueryLinksApi, type QueryTableApi, type RequestActivityApi, type RequestActivityEntry, type SavedQueriesApi, type SelectApi, type SelectionApi, type UsePropertyViewOptions, type UseQueryTableOptions, createFormulaWorker, evaluateFormulaRows, useAggregations, useColumnDrag, useObjectReferences, usePropertyView, useQueryFilters, useQueryTable, useSavedQueries, useSelect, useSelection };

package/dist/index.js

@@ -138,6 +138,7 @@ import {
   MAX_SUMMARY_COLUMNS,
   normalizeQueryState,
   predicatesOf as predicatesOf2,
+  withGroupingKeys,
   withoutGrouping,
   queriesEqual
 } from "@pythia-software/query-table-core";
@@ -171,46 +172,12 @@ function useGroupingController(api, source, model, inputs, supported, viewRevisi
     if (!keys.length && stage)
       previous.current = { query: api.query, revision: viewRevision };
     api.setQuery((current) => {
-      const before = current.grouping;
-      if (!keys.length) return before ? before.source : current;
-      if (!before) {
-        if (cached?.grouping && canRestore(current))
-          return {
-            ...cached,
-            grouping: { ...cached.grouping, source: current }
-          };
-        const grouping2 = {
-          keys,
-          summaries: [],
-          representative: null,
-          source: current
-        };
+      if (keys.length && !current.grouping && cached?.grouping && canRestore(current))
         return {
-          select: keys.map((field) => ({ field })),
-          where: [],
-          orderBy: [],
-          limit: current.limit,
-          offset: 0,
-          grouping: grouping2
+          ...cached,
+          grouping: { ...cached.grouping, source: current }
         };
-      }
-      const grouping = { ...before, keys };
-      const removed = new Set(before.keys.filter((key) => !keys.includes(key)));
-      const columns = current.select.length ? current.select : before.keys.map((field) => ({ field }));
-      return {
-        ...current,
-        grouping,
-        offset: 0,
-        aggregations: [],
-        select: [
-          ...keys.filter((key) => !before.keys.includes(key)).map((field) => ({ field })),
-          ...columns.filter((c) => !removed.has(c.field))
-        ],
-        where: current.where.filter(
-          (term) => !predicatesOf2(term).some((p) => removed.has(p.field))
-        ),
-        orderBy: current.orderBy.filter((term) => !removed.has(term.field))
-      };
+      return withGroupingKeys(current, keys);
     });
     setNotice(
       stage && api.query.aggregations?.length && keys.length ? "Grouping changed. Group metrics cleared; Undo restores them." : ""
@@ -274,9 +241,11 @@ function useGroupingController(api, source, model, inputs, supported, viewRevisi
   function changeSummary(id, op) {
     if (!stage) return;
     applyColumns(
-      stage.summaries.map(
-        (column) => column.id === id ? { ...column, op } : column
-      ),
+      stage.summaries.map((column) => {
+        if (column.id !== id) return column;
+        const { display: _display, ...rest } = column;
+        return op === "row" ? { ...rest, op } : { ...column, op };
+      }),
       api.select.visible
     );
   }
@@ -325,6 +294,7 @@ function useGroupingController(api, source, model, inputs, supported, viewRevisi
     grouped: api,
     schema: api.schema,
     view,
+    diagnostics: stage ? model.linkDiagnostics(stage) : [],
     inputs,
     notice,
     setNotice,
@@ -344,7 +314,8 @@ import {
   withoutGrouping as withoutGrouping2,
   sourceExecutionSchema,
   toQueryRequestV3,
-  validateQueryResultV3
+  validateQueryResultV3,
+  metricPopulationError as metricPopulationError2
 } from "@pythia-software/query-table-core";
 import { ITEM_DETAILS_COLUMN, itemPageFields } from "@pythia-software/query-table-core";
 
@@ -753,6 +724,7 @@ function validateComputedResponse(request, result, schema) {
 // src/useComputedColumns.ts
 import { useCallback as useCallback4, useEffect as useEffect4, useMemo as useMemo3, useRef as useRef4, useState as useState4 } from "react";
 import {
+  isGroupLinkField,
   applyQuery,
   compileFormula,
   computedFieldName,
@@ -908,7 +880,7 @@ function useComputedColumns(options) {
   }, [reload]);
   const inputFields = useMemo3(
     () => schema.fields.filter(isSelectable).filter(
-      (f) => f.source.kind === "backend" || f.source.accessor && f.source.dependencies
+      (f) => f.source.kind === "backend" || f.source.accessor && f.source.dependencies && !isGroupLinkField(f)
     ),
     [schema]
   );
@@ -1334,6 +1306,8 @@ import {
   evaluateMetrics,
   metricPlans,
   hasRegex as hasRegex2,
+  metricPopulationError,
+  predicatesOf as predicatesOf3,
   toAggregationQuery,
   toMetricQuery,
   validateMetric,
@@ -1348,7 +1322,7 @@ var abort = (signal) => {
 async function localMetrics(rows, query, context, signal) {
   const originalClauses = query.aggregations ?? [];
   const advanced = (query.aggregations ?? []).filter(
-    (c) => context.strictLocalMetrics || c.dateGrouping || isComputedField3(c.field ?? "") || c.groupBy.some(isComputedField3) || c.diagnostics?.length || c.expression !== void 0 || c.expressionY !== void 0 || c.scope !== void 0 || c.distribution || c.sort || c.groupLimit !== void 0
+    (c) => context.strictLocalMetrics || c.dateGrouping || isComputedField3(c.field ?? "") || c.groupBy.some(isComputedField3) || c.diagnostics?.length || c.expression !== void 0 || c.expressionY !== void 0 || c.scope !== void 0 || c.distribution || c.sort || c.groupLimit !== void 0 || c.where !== void 0 || c.minCount !== void 0
   );
   if (advanced.length && (originalClauses.length > 20 || normalizeQueryState2(query).aggregations?.length !== originalClauses.length))
     return evaluateMetrics(rows, query, context.schema, {
@@ -1466,7 +1440,7 @@ async function executeMetrics(query, context, signal) {
   const shown = clauses.filter(
     (c) => c.scope === "shownRows" && (!supportsV2 || needsWorker(c) || !!c.dateGrouping)
   );
-  const matching = clauses.filter(
+  let matching = clauses.filter(
     (c) => c.scope !== "shownRows" || supportsV2 && !needsWorker(c) && !c.dateGrouping
   );
   const results = [];
@@ -1478,6 +1452,9 @@ async function executeMetrics(query, context, signal) {
     const names = new Set(
       shown.flatMap((clause) => [
         ...clause.groupBy,
+        ...(clause.where ?? []).flatMap(
+          (term) => predicatesOf3(term).map((predicate) => predicate.field)
+        ),
         ...metricPlans(clause, context.schema, context.resolveComputed).flatMap(
           (p) => p.dependencies
         )
@@ -1509,20 +1486,37 @@ async function executeMetrics(query, context, signal) {
       ...(await localMetrics(context.shownRows, pageQuery, context, signal)).metrics
     );
   }
+  const unsupported = (clause, error) => results.push({ id: clause.id, buckets: [], error });
+  const calendar = matching.filter((c) => c.dateGrouping);
+  for (const clause of calendar)
+    unsupported(
+      clause,
+      "This server does not support calendar grouping. Enable the v3 query executor."
+    );
+  matching = matching.filter((c) => !c.dateGrouping);
+  {
+    const transport = context.transport;
+    if (transport?.fetchMetrics || transport?.fetchAggregations) {
+      const support = transport.fetchMetrics && transport.metricCapabilities?.version === 2 ? transport.metricCapabilities : {};
+      matching = matching.filter((c) => {
+        const error = metricPopulationError(c, support);
+        if (error) unsupported(c, error);
+        return !error;
+      });
+    }
+  }
   if (matching.length) {
-    if (matching.some((c) => c.dateGrouping))
-      throw Error(
-        "This server does not support calendar grouping. Enable the v3 query executor."
-      );
     const transport = context.transport;
-    const scoped = { ...query, aggregations: matching };
     if (transport?.fetchMetrics && transport.metricCapabilities?.version === 2) {
-      const request = toMetricQuery(scoped, context.schema, context.execution);
+      const capabilities = transport.metricCapabilities;
+      const request = toMetricQuery(
+        { ...query, aggregations: matching },
+        context.schema,
+        context.execution
+      );
       if (request.diagnostics.length)
         throw Error(request.diagnostics.map((d) => d.message).join(" "));
-      if (matching.some((c) => c.scope === "shownRows") && !transport.metricCapabilities.shownRows)
-        throw Error("This server does not support shown-row metrics.");
-      if (request.profile && transport.metricCapabilities.profile && request.profile !== transport.metricCapabilities.profile)
+      if (request.profile && capabilities.profile && request.profile !== capabilities.profile)
         throw Error(
           "Metric transport and computed execution profiles do not match. Refresh the handshake."
         );
@@ -1543,28 +1537,42 @@ async function executeMetrics(query, context, signal) {
         ...context.schema,
         fields: [...remoteFields.values()]
       };
-      if (matching.some(
-        (clause) => [
+      const wire = new Map(request.metrics.map((m) => [m.id, m]));
+      const limitation = (clause) => {
+        if (clause.scope === "shownRows" && !capabilities.shownRows)
+          return "This server does not support shown-row metrics.";
+        if (!capabilities.computedFields && [
           ...clause.groupBy,
           ...metricPlans(clause, remoteSchema).flatMap(
             (plan) => plan.dependencies
           )
-        ].some(isComputedField3)
-      ) && !transport.metricCapabilities.computedFields)
-        throw Error("This metric server does not support computed fields.");
-      if (request.metrics.some(
-        (c) => !c.distribution && (c.expression !== void 0 || c.expressionY !== void 0)
-      ) && !transport.metricCapabilities.expressions)
-        throw Error(
-          "This server does not support composed metric expressions."
+        ].some(isComputedField3))
+          return "This metric server does not support computed fields.";
+        const sent = wire.get(clause.id);
+        if (!capabilities.expressions && sent && !sent.distribution && (sent.expression !== void 0 || sent.expressionY !== void 0))
+          return "This server does not support composed metric expressions.";
+        if (!capabilities.distributions && clause.distribution && (!clause.display || ["box", "histogram"].includes(clause.display.kind)))
+          return "This server does not support distributions.";
+        return void 0;
+      };
+      const rejected = /* @__PURE__ */ new Set();
+      for (const clause of matching) {
+        const error = limitation(clause);
+        if (error) {
+          rejected.add(clause.id);
+          unsupported(clause, error);
+        }
+      }
+      const metrics = request.metrics.filter((m) => !rejected.has(m.id));
+      if (metrics.length)
+        results.push(
+          ...(await transport.fetchMetrics({ ...request, metrics }, signal)).metrics
         );
-      if (matching.some(
-        (c) => c.distribution && (!c.display || ["box", "histogram"].includes(c.display.kind))
-      ) && !transport.metricCapabilities.distributions)
-        throw Error("This server does not support distributions.");
-      results.push(...(await transport.fetchMetrics(request, signal)).metrics);
     } else if (transport?.fetchAggregations) {
-      const request = toAggregationQuery(scoped, context.schema);
+      const request = toAggregationQuery(
+        { ...query, aggregations: matching },
+        context.schema
+      );
       if (request.diagnostics?.length)
         throw Error(request.diagnostics.map((d) => d.message).join(" "));
       results.push(
@@ -2755,17 +2763,36 @@ function useQueryTable(opts) {
   );
   const executeV3Metrics = useCallback12(async (metricQuery, signal) => {
     if (!transport?.fetchQueryV3 || transport.queryCapabilities?.version !== 3) throw Error("The v3 query executor is unavailable.");
-    const request = toQueryRequestV3(
-      query.grouping ? { ...metricQuery, grouping: query.grouping } : metricQuery,
-      sourceSchema,
-      transport.queryCapabilities,
-      opts.computedExecution,
-      { now: groupingNow ?? (opts.evaluationNow ?? Date.now)(), rows: false }
-    );
-    if (request.diagnostics.length) throw Error(request.diagnostics.join(" "));
-    const result = await transport.fetchQueryV3(request, signal);
-    validateQueryResultV3(result, request, query.grouping ? schema : sourceCatalogue);
-    return { metrics: result.metrics };
+    const capabilities = transport.queryCapabilities;
+    const refused = /* @__PURE__ */ new Map();
+    for (const clause of metricQuery.aggregations ?? []) {
+      const issue = metricPopulationError2(clause, { filters: capabilities.metricFilters, minCount: capabilities.metricMinCount });
+      if (issue) refused.set(clause.id, issue);
+    }
+    const runnable = (metricQuery.aggregations ?? []).filter((clause) => !refused.has(clause.id));
+    let metrics = [];
+    if (runnable.length) {
+      const scoped = { ...metricQuery, aggregations: runnable };
+      const request = toQueryRequestV3(
+        query.grouping ? { ...scoped, grouping: query.grouping } : scoped,
+        sourceSchema,
+        capabilities,
+        opts.computedExecution,
+        { now: groupingNow ?? (opts.evaluationNow ?? Date.now)(), rows: false }
+      );
+      if (request.diagnostics.length) throw Error(request.diagnostics.join(" "));
+      const result = await transport.fetchQueryV3(request, signal);
+      validateQueryResultV3(result, request, query.grouping ? schema : sourceCatalogue);
+      metrics = result.metrics;
+    }
+    if (!refused.size) return { metrics };
+    const byId = new Map(metrics.map((metric) => [metric.id, metric]));
+    return { metrics: (metricQuery.aggregations ?? []).flatMap((clause) => {
+      const issue = refused.get(clause.id);
+      if (issue) return [{ id: clause.id, buckets: [], error: issue }];
+      const metric = byId.get(clause.id);
+      return metric ? [metric] : [];
+    }) };
   }, [transport, sourceSchema, sourceCatalogue, schema, opts.computedExecution, groupKey, groupingNow, opts.evaluationNow]);
   const previewGrouping = useCallback12(async (draft, signal) => {
     if (!active || !storageReady || restoration.loading || restoration.error) throw Error("Wait for query restoration before previewing groups.");
@@ -3287,6 +3314,7 @@ export {
   useColumnDrag,
   useObjectReferences,
   usePropertyView,
+  useQueryFilters,
   useQueryTable,
   useSavedQueries,
   useSelect,