@pythia-software/query-table-react 0.9.3 → 0.9.4

package/dist/index.js

@@ -312,9 +312,9 @@ import {
   createGroupingModel,
   prepareGrouping,
   withoutGrouping as withoutGrouping2,
-  sourceExecutionSchema,
-  toQueryRequestV3,
-  validateQueryResultV3,
+  sourceExecutionSchema as sourceExecutionSchema2,
+  toQueryRequestV3 as toQueryRequestV32,
+  validateQueryResultV3 as validateQueryResultV32,
   metricPopulationError as metricPopulationError2
 } from "@pythia-software/query-table-core";
 import { ITEM_DETAILS_COLUMN, itemPageFields } from "@pythia-software/query-table-core";
@@ -688,7 +688,8 @@ function validateComputedResponse(request, result, schema) {
     );
   const executed = /* @__PURE__ */ new Set([
     ...request.select.filter(isComputedField),
-    ...request.orderBy.map((term) => term.field).filter(isComputedField)
+    ...request.orderBy.map((term) => term.field).filter(isComputedField),
+    ...request.where.flatMap((term) => ("any" in term ? term.any : [term]).map((predicate) => predicate.field)).filter(isComputedField)
   ]);
   for (const [name, revision] of Object.entries(request.expectedRevisions)) {
     const id = name.replace(/^@computed\//, "");
@@ -721,6 +722,53 @@ function validateComputedResponse(request, result, schema) {
   }
 }
 
+// src/previewRows.ts
+import {
+  sourceExecutionSchema,
+  toQueryRequestV3,
+  toServerQuery,
+  toServerQueryV2,
+  validateQueryResultV3
+} from "@pythia-software/query-table-core";
+async function fetchPreviewRows(transport, query, schema, execution, definitions, now, signal, baseSchema = schema) {
+  if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+  const sourceSchema = sourceExecutionSchema(baseSchema, execution, definitions);
+  let result;
+  const computedFilter = query.where.some((term) => ("any" in term ? term.any : [term]).some((predicate) => predicate.field.startsWith("@computed/")));
+  if (transport.fetchRowsV2 && execution && !query.grouping && !computedFilter) {
+    const request = toServerQueryV2(query, sourceSchema, execution);
+    if (request.diagnostics.length)
+      throw Error(request.diagnostics.map((issue) => issue.message).join(" "));
+    for (const definition of definitions) {
+      if (executionRevision(execution, definition.id) !== definition.revision && (request.select.includes(`@computed/${definition.id}`) || request.orderBy.some((term) => term.field === `@computed/${definition.id}`) || request.where.some((term) => ("any" in term ? term.any : [term]).some((predicate) => predicate.field === `@computed/${definition.id}`))))
+        throw Error("Computed definitions changed. Refresh the server execution handshake.");
+    }
+    const response = await transport.fetchRowsV2(request, signal);
+    validateComputedResponse(request, response, sourceSchema);
+    result = response;
+  } else if (transport.fetchQueryV3 && transport.queryCapabilities?.version === 3) {
+    const request = toQueryRequestV3(
+      { ...query, aggregations: [] },
+      sourceSchema,
+      transport.queryCapabilities,
+      execution,
+      { now }
+    );
+    if (request.diagnostics.length) throw Error(request.diagnostics.join(" "));
+    const response = await transport.fetchQueryV3(request, signal);
+    validateQueryResultV3(response, request, query.grouping ? schema : sourceSchema);
+    result = { rows: response.rows, total: response.total };
+  } else if (transport.fetchRows && !query.grouping && !(computedFilter && transport.fetchRowsV2 && execution)) {
+    result = await transport.fetchRows(toServerQuery(query, schema), signal);
+  } else {
+    throw Error("Row execution requires fetchRows, negotiated fetchRowsV2, or negotiated fetchQueryV3.");
+  }
+  if (signal.aborted) throw new DOMException("Aborted", "AbortError");
+  if (!Number.isSafeInteger(result.total) || result.total < 0 || !Array.isArray(result.rows) || result.rows.length > query.limit)
+    throw Error("Invalid preview row response.");
+  return result;
+}
+
 // src/useComputedColumns.ts
 import { useCallback as useCallback4, useEffect as useEffect4, useMemo as useMemo3, useRef as useRef4, useState as useState4 } from "react";
 import {
@@ -732,7 +780,6 @@ import {
   isComputedField as isComputedField2,
   memoryComputedColumnStore,
   readFieldValue as readFieldValue2,
-  toServerQuery,
   validateComputedColumn,
   isSelectable,
   hasRegex
@@ -1101,59 +1148,80 @@ function useComputedColumns(options) {
     },
     [compile, store, schema.name]
   );
+  const previewRequest = useRef4(null);
   const preview = useCallback4(
     async (source, count, signal, editingId, includeInputs = true) => {
-      if (!Number.isInteger(count) || count < 1 || count > 1e4)
-        throw new Error("Choose between 1 and 10,000 rows.");
-      const plan = compile(source, editingId);
-      let batch = [], total = 0;
-      if (transport) {
-        const request = toServerQuery(
-          {
+      previewRequest.current?.abort();
+      const controller = new AbortController();
+      previewRequest.current = controller;
+      const abort2 = () => controller.abort();
+      signal?.addEventListener("abort", abort2, { once: true });
+      if (signal?.aborted) controller.abort();
+      try {
+        if (!Number.isInteger(count) || count < 1 || count > 1e4)
+          throw new Error("Choose between 1 and 10,000 rows.");
+        const plan = compile(source, editingId);
+        let batch = [], total = 0;
+        if (transport) {
+          const request = {
             ...query,
+            ...options.previewQuery?.grouping ? { grouping: options.previewQuery.grouping } : {},
             select: [
               .../* @__PURE__ */ new Set([schema.idField, ...backendDependencies(plan)])
             ].map((field) => ({ field })),
             limit: Math.min(count, 500),
             offset: 0
-          },
-          schema
-        );
-        while (batch.length < count) {
-          if (signal?.aborted) throw new DOMException("Aborted", "AbortError");
-          const res = await transport.fetchRows(
-            {
-              ...request,
-              offset: batch.length,
-              limit: Math.min(500, count - batch.length)
-            },
-            signal
+          };
+          const now = options.now ?? Date.now();
+          const computedFilter = request.where.some((term) => ("any" in term ? term.any : [term]).some((predicate) => isComputedField2(predicate.field)));
+          const v3 = !(transport.fetchRowsV2 && options.execution && !request.grouping && !computedFilter) && transport.fetchQueryV3 && transport.queryCapabilities?.version === 3;
+          const pageSize = Math.min(500, v3 ? transport.queryCapabilities.maxRows : 500);
+          if (!Number.isInteger(pageSize) || pageSize < 1) throw Error("Invalid negotiated preview row limit.");
+          while (batch.length < count) {
+            const res = await fetchPreviewRows(
+              transport,
+              {
+                ...request,
+                offset: batch.length,
+                limit: Math.min(pageSize, count - batch.length)
+              },
+              schema,
+              options.execution,
+              definitions,
+              now,
+              controller.signal,
+              options.sourceSchema
+            );
+            total = res.total;
+            batch.push(...res.rows.slice(0, count - batch.length));
+            if (!res.rows.length || batch.length >= total) break;
+          }
+        } else {
+          const result = applyQuery(
+            clientRows ?? [],
+            { ...query, limit: count, offset: 0 },
+            schema
           );
-          total = res.total;
-          batch.push(...res.rows.slice(0, count - batch.length));
-          if (!res.rows.length || batch.length >= total) break;
+          batch = result.rows;
+          total = result.total;
         }
-      } else {
-        const result = applyQuery(
-          clientRows ?? [],
-          { ...query, limit: count, offset: 0 },
-          schema
+        const inputs = inputsFor(plan, batch), results = await evaluateFormulaRows(
+          plan.ast,
+          inputs,
+          controller.signal,
+          workerFactory
+        );
+        if (controller.signal.aborted) throw new DOMException("Aborted", "AbortError");
+        return groupPreview(
+          includeInputs ? plan.dependencies : [],
+          inputs,
+          results,
+          total
         );
-        batch = result.rows;
-        total = result.total;
+      } finally {
+        signal?.removeEventListener("abort", abort2);
+        if (previewRequest.current === controller) previewRequest.current = null;
       }
-      const inputs = inputsFor(plan, batch), results = await evaluateFormulaRows(
-        plan.ast,
-        inputs,
-        signal,
-        workerFactory
-      );
-      return groupPreview(
-        includeInputs ? plan.dependencies : [],
-        inputs,
-        results,
-        total
-      );
     },
     [
       compile,
@@ -1163,9 +1231,15 @@ function useComputedColumns(options) {
       backendDependencies,
       clientRows,
       inputsFor,
-      workerFactory
+      workerFactory,
+      options.execution,
+      definitions,
+      options.sourceSchema,
+      options.previewQuery?.grouping,
+      options.now
     ]
   );
+  useEffect4(() => () => previewRequest.current?.abort(), [preview]);
   return {
     displaySchema,
     api: {
@@ -1198,7 +1272,7 @@ import {
   metricDependencies,
   isComputedField as isComputedField4,
   computedFieldName as computedFieldName2,
-  toServerQueryV2
+  toServerQueryV2 as toServerQueryV22
 } from "@pythia-software/query-table-core";
 
 // src/useRequestActivity.ts
@@ -2318,7 +2392,7 @@ function useQueryTable(opts) {
     () => opts.canonicalizeQuery?.(storedQuery) ?? storedQuery,
     [storedQuery, opts.canonicalizeQuery]
   );
-  const sourceCatalogue = useMemo9(() => sourceExecutionSchema(sourceSchema, opts.computedExecution), [sourceSchema, opts.computedExecution]);
+  const sourceCatalogue = useMemo9(() => sourceExecutionSchema2(sourceSchema, opts.computedExecution), [sourceSchema, opts.computedExecution]);
   const sourceRows = providedRows;
   const groupingModel = useMemo9(() => createGroupingModel(sourceCatalogue), [sourceCatalogue]);
   const remoteGrouping = !!transport?.fetchQueryV3 && transport.queryCapabilities?.version === 3 && transport.queryCapabilities.groupedRows;
@@ -2493,6 +2567,9 @@ function useQueryTable(opts) {
   const { api: computed, displaySchema } = useComputedColumns({
     schema,
     query: executionQuery,
+    sourceSchema,
+    previewQuery: query,
+    ...groupingNow !== void 0 ? { now: groupingNow } : {},
     rows,
     serverComputed,
     ...serverExecution ? { serverExecution } : {},
@@ -2508,7 +2585,7 @@ function useQueryTable(opts) {
     (name) => isComputedField4(name) ? computed.compile(`[${name.replace(/]/g, "]] ".trim())}]`) : void 0,
     [computed.compile]
   );
-  const metricCompileSchema = useMemo9(() => opts.metricExecution ? sourceExecutionSchema(displaySchema, opts.metricExecution, computed.definitions) : displaySchema, [displaySchema, opts.metricExecution, computed.definitions]);
+  const metricCompileSchema = useMemo9(() => opts.metricExecution ? sourceExecutionSchema2(displaySchema, opts.metricExecution, computed.definitions) : displaySchema, [displaySchema, opts.metricExecution, computed.definitions]);
   const metricCompile = useCallback12(
     (clause) => {
       const diagnostics = validateMetric2(
@@ -2538,7 +2615,7 @@ function useQueryTable(opts) {
       ...query.select.length ? query.select : defaults.select,
       ...pageFields.filter((name) => displaySchema.fields.some((field) => field.name === name)).map((field) => ({ field }))
     ] } : executionQuery;
-    const v2Request = execution && transport?.fetchRowsV2 ? toServerQueryV2(requestQuery, displaySchema, execution) : void 0;
+    const v2Request = execution && transport?.fetchRowsV2 ? toServerQueryV22(requestQuery, displaySchema, execution) : void 0;
     const request = v2Request ?? toServerQuery2(requestQuery, displaySchema);
     if (v2Request)
       for (const definition of computed.definitions) {
@@ -2622,8 +2699,8 @@ function useQueryTable(opts) {
       try {
         validateExecution(query);
         if (transport) {
-          if (transport.fetchQueryV3 && transport.queryCapabilities?.version === 3 && (query.grouping || query.select.some((column) => isComputedField4(column.field)) || query.orderBy.some((term) => isComputedField4(term.field)) || query.where.some((term) => ("any" in term ? term.any : [term]).some((predicate) => isComputedField4(predicate.field))))) {
-            const request = toQueryRequestV3(
+          if (transport.fetchQueryV3 && transport.queryCapabilities?.version === 3 && (query.grouping || query.select.some((column) => isComputedField4(column.field)) || query.orderBy.some((term) => isComputedField4(term.field)) || query.where.some((term) => ("any" in term ? term.any : [term]).some((predicate) => isComputedField4(predicate.field))) || !transport.fetchRows && !(transport.fetchRowsV2 && opts.computedExecution))) {
+            const request = toQueryRequestV32(
               { ...query, aggregations: [], select: [
                 ...query.select.filter((column) => isComputedField4(column.field)),
                 ...serverRowQuery.select.map((field) => ({ field }))
@@ -2635,7 +2712,7 @@ function useQueryTable(opts) {
             );
             if (request.diagnostics.length) throw Error(request.diagnostics.join(" "));
             const result = await transport.fetchQueryV3(request, ac.signal);
-            validateQueryResultV3(result, request, query.grouping ? schema : sourceCatalogue);
+            validateQueryResultV32(result, request, query.grouping ? schema : sourceCatalogue);
             if (!cancelled) {
               setCommittedFields(request.result.select);
               setServerExecution(result.execution);
@@ -2651,6 +2728,8 @@ function useQueryTable(opts) {
             return;
           }
           const useV2 = "version" in serverRowQuery && transport.fetchRowsV2;
+          if (!useV2 && !transport.fetchRows)
+            throw Error("Row execution requires fetchRows, negotiated fetchRowsV2, or negotiated fetchQueryV3.");
           if ("diagnostics" in serverRowQuery && Array.isArray(serverRowQuery.diagnostics) && serverRowQuery.diagnostics.length)
             throw Error(
               serverRowQuery.diagnostics.map((d) => d.message).join(" ")
@@ -2787,7 +2866,7 @@ function useQueryTable(opts) {
   const metricExecution = opts.metricExecution ?? (opts.computedExecution ? pageReady && serverExecution ? serverExecution : opts.computedExecution : void 0);
   const v3MetricExecution = opts.metricExecution ?? opts.computedExecution;
   const metricSourceCatalogue = useMemo9(
-    () => sourceExecutionSchema(sourceSchema, v3MetricExecution),
+    () => sourceExecutionSchema2(sourceSchema, v3MetricExecution),
     [sourceSchema, v3MetricExecution]
   );
   const executeV3Metrics = useCallback12(async (metricQuery, signal) => {
@@ -2802,7 +2881,7 @@ function useQueryTable(opts) {
     let metrics = [];
     if (runnable.length) {
       const scoped = { ...metricQuery, aggregations: runnable };
-      const request = toQueryRequestV3(
+      const request = toQueryRequestV32(
         query.grouping ? { ...scoped, grouping: query.grouping } : scoped,
         sourceSchema,
         capabilities,
@@ -2811,7 +2890,7 @@ function useQueryTable(opts) {
       );
       if (request.diagnostics.length) throw Error(request.diagnostics.join(" "));
       const result = await metricTransport.fetchQueryV3(request, signal);
-      validateQueryResultV3(result, request, query.grouping ? schema : metricSourceCatalogue);
+      validateQueryResultV32(result, request, query.grouping ? schema : metricSourceCatalogue);
       metrics = result.metrics;
     }
     if (!refused.size) return { metrics };
@@ -2826,7 +2905,7 @@ function useQueryTable(opts) {
   const previewGrouping = useCallback12(async (draft, signal) => {
     if (!active || !storageReady || restoration.loading || restoration.error) throw Error("Wait for query restoration before previewing groups.");
     if (!transport?.fetchQueryV3 || !transport.queryCapabilities?.groupedRows || !draft.grouping) throw Error("The server group preview is unavailable.");
-    const request = toQueryRequestV3(
+    const request = toQueryRequestV32(
       { ...draft, aggregations: [] },
       sourceSchema,
       transport.queryCapabilities,
@@ -2835,7 +2914,7 @@ function useQueryTable(opts) {
     );
     if (request.diagnostics.length) throw Error(request.diagnostics.join(" "));
     const result = await transport.fetchQueryV3(request, signal);
-    validateQueryResultV3(result, request, groupingModel.resultSchema(draft.grouping.keys, draft.grouping.summaries));
+    validateQueryResultV32(result, request, groupingModel.resultSchema(draft.grouping.keys, draft.grouping.summaries));
     return { rows: result.rows, total: result.total, sourceTotal: result.sourceTotal };
   }, [transport, sourceSchema, opts.computedExecution, groupingModel, groupingNow, opts.evaluationNow, active, storageReady, restoration.loading, restoration.error]);
   const aggState = useAggregations(