@antelopejs/dms 0.11.1 → 0.12.1

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTableRows.ts

@@ -1,6 +1,8 @@
 import { get } from "@nuxt/ui/runtime/utils/index.js";
 import { computed } from "vue";
+import { stringifyQuery, withQuery } from "ufo";
 import { interpolateUrl } from "#dms-core/app/utils/url-interpolation";
+import { isString } from "#dms-core/app/utils/type-check";
 import type {
   TableViewColumn,
   TableViewListResponse,
@@ -18,6 +20,7 @@ import {
   usePeriodScope,
 } from "#dms-core/app/composables/period/usePeriodScope";
 
+// oxlint-disable-next-line anti-slop/no-unsafe-dictionary-type -- Source plugins and data controllers own different query keys and values. TableQueryParams excludes plugin extensions and malformed query handling; retain the open request contract.
 type Query = Record<string, unknown>;
 
 /** One count of a batch: its id and its list query. */
@@ -56,10 +59,51 @@ const DESCENDING = "desc";
  */
 export const LIVE_HELD_AT_QUERY_KEY = "liveHeldAt";
 const NO_ROUTE_VALUES: ReplaceUrlVariablesContext = { routeQuery: {} };
+const MAX_BATCH_COUNT_QUERIES = 50;
+const MAX_BATCH_COUNT_TARGET_BYTES = 8_192;
+
+function encodeCountQuery({ id, query }: TableCountQuery): string {
+  const values = Object.fromEntries(
+    Object.entries(query)
+      .filter(([, value]) => value !== undefined)
+      .map(([key, value]) => [
+        key,
+        Array.isArray(value) ? value.map(String) : String(value),
+      ]),
+  );
+  return `${encodeURIComponent(id)}?${stringifyQuery(values)}`;
+}
+
+function countBatchTargetBytes(location: string, entries: string[]): number {
+  const url = new URL(location, "http://dms.invalid");
+  const target = withQuery(url.pathname + url.search, { query: entries });
+  return new TextEncoder().encode(target).byteLength;
+}
+
+function packCountQueries(
+  location: string,
+  queries: TableCountQuery[],
+): string[][] {
+  const batches: string[][] = [];
+  let batch: string[] = [];
+  for (const entry of queries.map(encodeCountQuery)) {
+    if (
+      batch.length > 0 &&
+      (batch.length >= MAX_BATCH_COUNT_QUERIES ||
+        countBatchTargetBytes(location, [...batch, entry]) >
+          MAX_BATCH_COUNT_TARGET_BYTES)
+    ) {
+      batches.push(batch);
+      batch = [];
+    }
+    batch.push(entry);
+  }
+  batches.push(batch);
+  return batches;
+}
 
 type SourceCapabilities = TableViewSourceConfig["capabilities"];
 
-// Which capability lets a query key reach the route.
 const QUERY_KEY_CAPABILITIES: Array<
   [matches: (key: string) => boolean, capability: keyof SourceCapabilities]
 > = [
@@ -101,7 +145,7 @@ export function processSourceRows<T extends Record<string, unknown>>(
   pinnedRows?: RowActionRule,
 ): TableViewListResponse<T> {
   let processed = rows;
-  const search = typeof query.search === "string" ? query.search.trim() : "";
+  const search = isString(query.search) ? query.search.trim() : "";
   if (!capabilities.search && search) {
     const needle = search.toLocaleLowerCase();
     const keys = columns.map((column) => column.accessorKey);
@@ -111,7 +155,7 @@ export function processSourceRows<T extends Record<string, unknown>>(
       ),
     );
   }
-  const sortKey = typeof query.sortKey === "string" ? query.sortKey : "";
+  const sortKey = isString(query.sortKey) ? query.sortKey : "";
   if (!capabilities.sort && sortKey) {
     const direction = query.sortDirection === DESCENDING ? -1 : 1;
     processed = [...processed].sort(
@@ -181,21 +225,7 @@ function emptySourcePage<T>(query: Query): TableViewListResponse<T> {
   };
 }
 
-/**
- * Where a table view reads its rows: its data controller's routes, or the
- * route of a `TableView.fromSource` table — which answers `{ results, total }`
- * for the part of the query it handles. A route answering every row leaves
- * the rest to the browser; a route answering one page is taken as it is.
- *
- * A source's `{{params.X}}` and `{{query.X}}` tokens are filled from `route`;
- * while one has no value nothing is requested and the list is empty. A
- * source's `periodScope` adds the period of its selector to the URL, like a
- * chart's; until that selector registers, nothing is requested and the list
- * answers `null`, which the table draws as its skeleton. `sourceUrl` is the
- * URL requested, for the caller to list again when it changes. The rows
- * `pinnedRows` accepts lead each list answered.
- */
-export function useTableRows<T extends Record<string, unknown>>(
+function createTableSource<T extends Record<string, unknown>>(
   options: TableRowsOptions,
 ) {
   const { api, location, source, columns } = options;
@@ -213,10 +243,6 @@ export function useTableRows<T extends Record<string, unknown>>(
     return source.periodScope ? appendPeriodToUrl(url, periodScope.value) : url;
   });
 
-  // Reads of the same source with the same query, while one is in flight,
-  // share it: the list and the counter of a tab that filters nothing the
-  // route handles ask it the same thing at the same time. The request is
-  // cancelled once every caller waiting on it has given up.
   const sharedReads = new Map<string, SharedRead<T>>();
   const readSource = (
     url: string,
@@ -240,7 +266,7 @@ export function useTableRows<T extends Record<string, unknown>>(
       read = started;
     }
     const joined = read;
-    // A caller without a signal never gives up: the request stays.
+
     joined.waiting += 1;
     if (!signal) return joined.answer;
     return awaitUnlessAborted(joined.answer, signal, () => {
@@ -281,12 +307,34 @@ export function useTableRows<T extends Record<string, unknown>>(
     );
   };
 
+  return { api, location, source, sourceUrl, isPeriodPending, listFromSource };
+}
+
+/**
+ * Where a table view reads its rows: its data controller's routes, or the
+ * route of a `TableView.fromSource` table — which answers `{ results, total }`
+ * for the part of the query it handles. A route answering every row leaves
+ * the rest to the browser; a route answering one page is taken as it is.
+ *
+ * A source's `{{params.X}}` and `{{query.X}}` tokens are filled from `route`;
+ * while one has no value nothing is requested and the list is empty. A
+ * source's `periodScope` adds the period of its selector to the URL, like a
+ * chart's; until that selector registers, nothing is requested and the list
+ * answers `null`, which the table draws as its skeleton. `sourceUrl` is the
+ * URL requested, for the caller to list again when it changes. The rows
+ * `pinnedRows` accepts lead each list answered.
+ */
+export function useTableRows<T extends Record<string, unknown>>(
+  options: TableRowsOptions,
+) {
+  const { api, location, source, sourceUrl, isPeriodPending, listFromSource } =
+    createTableSource<T>(options);
+
   const withPinnedRows = (
     page: TableViewListResponse<T> | null,
   ): TableViewListResponse<T> | null =>
     page && { ...page, results: pinRows(page.results, options.pinnedRows?.()) };
 
-  // The list the route answers, before the pinned rows lead it.
   const listAnswered = (
     query: Query,
     signal?: AbortSignal,
@@ -295,7 +343,6 @@ export function useTableRows<T extends Record<string, unknown>>(
       ? listFromSource(source, query, signal)
       : api<TableViewListResponse<T>>(`${location}/list`, { query, signal });
 
-  // `signal` aborts the request once its answer is no longer wanted.
   const list = async (
     query: Query,
     signal?: AbortSignal,
@@ -338,17 +385,21 @@ export function useTableRows<T extends Record<string, unknown>>(
     };
   };
 
-  // A source answers its totals one list at a time.
   const countBatch = async (
     queries: TableCountQuery[],
     signal?: AbortSignal,
   ): Promise<Record<string, number>> => {
     if (!source) {
-      return api<Record<string, number>>(`${location}/count/batch`, {
-        method: "POST",
-        body: { queries },
-        signal,
-      });
+      const endpoint = `${location}/count/batch`;
+      const counts = await Promise.all(
+        packCountQueries(endpoint, queries).map((entries) =>
+          api<Record<string, number>>(endpoint, {
+            query: { query: entries },
+            signal,
+          }),
+        ),
+      );
+      return Object.assign({}, ...counts);
     }
     const totals = await Promise.all(
       queries.map(async ({ id, query }) => {
@@ -363,8 +414,6 @@ export function useTableRows<T extends Record<string, unknown>>(
     return Object.fromEntries(totals.flat());
   };
 
-  // A source reads one row through its `fetchRowUrl`, if it declares one. It
-  // sends no list query, the period included: one row by id depends on none.
   const getSourceRow = (
     sourceConfig: TableViewSourceConfig,
     id: string,

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTableUrlTab.ts

@@ -1,6 +1,7 @@
 import { router as inertiaRouter } from "@inertiajs/vue3";
 import { onBeforeUnmount, onMounted, watch, type Ref } from "vue";
 import { queryOfUrl } from "./utils/urlFilters";
+import type { LocationQuery } from "#dms/frontend-module";
 import {
   readTableUrlKey,
   type TableUrlScope,
@@ -11,7 +12,7 @@ const TAB_URL_KEY = "tab";
 
 /** The route fields the URL tab is read from. */
 export interface TableUrlTabRoute {
-  query: Record<string, unknown>;
+  query: LocationQuery;
 }
 
 /** What `useTableUrlTab` reads the tab from and drives. */
@@ -29,7 +30,7 @@ export interface TableUrlTabOptions {
  * carrying a single table view), as it reads on arrival.
  */
 export function readTableUrlTab(
-  query: Record<string, unknown>,
+  query: LocationQuery,
   urlScope: TableUrlScope,
 ): string | undefined {
   return readTableUrlKey(query, urlScope, TAB_URL_KEY).value;
@@ -46,17 +47,13 @@ export function readTableUrlTab(
 export function useTableUrlTab(options: TableUrlTabOptions): void {
   const { activeTabId, urlScope } = options;
 
-  const follow = (query: Record<string, unknown>) => {
+  const follow = (query: LocationQuery) => {
     const tabId = readTableUrlTab(query, urlScope);
     if (!tabId || tabId === activeTabId.value) return;
     if (!options.isOpenable(tabId)) return;
     activeTabId.value = tabId;
   };
 
-  // The tab is written in place, so the route keeps the value of the last
-  // visit: a link back to that tab leaves it unchanged, and only the visit
-  // tells it was followed. A `router.replace`, which Inertia does not
-  // announce, still moves the route.
   watch(
     () => readTableUrlTab(options.route.query, urlScope),
     () => follow(options.route.query),

package/frontend-vue/layers/dms-ui/app/build/composables/table-view/useTableViewConfig.ts

@@ -13,12 +13,12 @@ import { buildInitialColumnVisibility } from "./utils/columnVisibility";
 import type { TableViewFormPages } from "./utils/formTexts";
 
 const BUILTIN_DISPLAYS: Record<
-  string,
+  TableViewDisplayConfig["id"],
   Pick<TableViewDisplayConfig, "selfManagedData" | "capabilities">
 > = {
   [TABLE_DISPLAY_ID]: { capabilities: { columnManagement: true } },
   [KANBAN_DISPLAY_ID]: { selfManagedData: true, capabilities: { tabs: false } },
-  // The grid's columns, listed sorted on the grouped column.
+
   [GROUPED_DISPLAY_ID]: {
     capabilities: { columnManagement: true, sorting: false },
   },
@@ -29,8 +29,7 @@ const withBuiltinDefaults = (
 ): TableViewDisplayConfig => {
   const builtin = BUILTIN_DISPLAYS[entry.id];
   if (!builtin) return entry;
-  // Per-key merge so a partial override (e.g. kanban { filters: false }) keeps
-  // the other built-in defaults (e.g. tabs: false) instead of dropping them.
+
   const capabilities =
     entry.capabilities || builtin.capabilities
       ? { ...builtin.capabilities, ...entry.capabilities }
@@ -42,8 +41,6 @@ const withBuiltinDefaults = (
   };
 };
 
-// The per-page slugs the table view declares are resolved server-side and
-// arrive as `formPages`; the frontend reads only the texts of `pages`.
 export interface FormContainer {
   type: FormContainerType;
   size?: ModalSize;
@@ -102,9 +99,6 @@ export const useTableViewConfig = <T extends Data>(
       .map((col) => ({ ...col, header: processI18n(col.header) })),
   );
 
-  // Config-derived (SSR-safe; the registry is client-only): the listed
-  // `displays`, else the built-in `table` alone. Built-in defaults
-  // (selfManagedData/capabilities) are merged per id.
   const resolvedDisplays: TableViewDisplayConfig[] = (
     config.displays ?? [{ id: TABLE_DISPLAY_ID }]
   ).map(withBuiltinDefaults);