@antelopejs/dms 0.9.8 → 0.11.0

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

@@ -0,0 +1,78 @@
+import { router as inertiaRouter } from "@inertiajs/vue3";
+import { onBeforeUnmount, onMounted } from "vue";
+import type { QueryParamFilters } from "../../../composables/table-view/types/config";
+import { isLinkedVisit } from "./utils/linkedArrival";
+import { queryOfUrl } from "./utils/urlFilters";
+import type { TableUrlScope } from "./utils/views";
+
+const URL_BASE = "http://dms.invalid";
+
+/** What `useTableLinkedVisit` reads a visit against, and what it calls. */
+export interface TableLinkedVisitOptions {
+  route: { path: string; query: Record<string, unknown> };
+  urlScope: TableUrlScope;
+  queryParamFilters: QueryParamFilters | undefined;
+  activeView: () => string | undefined;
+  activeTab: () => string;
+  canOpenView: (id: string) => boolean;
+  canOpenTab: (id: string) => boolean;
+  /** Opens the table on what the visit's link names, as an arrival would. */
+  follow: (query: Record<string, unknown>) => void;
+}
+
+/**
+ * Follows a link to the page the table is already shown on (a notification,
+ * a menu entry, back and forward): Inertia keeps the page mounted, so the
+ * table reads the visit's query as an arrival would (`isLinkedVisit`). A
+ * link clicked is announced as a client visit pushed, even to the URL shown,
+ * which Inertia turns into a replace without a `navigate` event; a page
+ * control rebuilding the query replaces it, and is no link. A visit to
+ * another page is left alone: the table is about to unmount.
+ */
+export function useTableLinkedVisit(options: TableLinkedVisitOptions): void {
+  // The page the table is shown on, as the visit that mounted it reached it.
+  const pathname = options.route.path;
+  let previousQuery: Record<string, unknown> = { ...options.route.query };
+  // A pushed visit announces itself twice when it changes the URL.
+  let followedVisitId: string | undefined;
+  const stops: Array<() => void> = [];
+
+  const read = (
+    url: string,
+    visitId: string | undefined,
+    isLinkClick: boolean,
+  ) => {
+    const query = queryOfUrl(url);
+    const lastQuery = previousQuery;
+    previousQuery = query;
+    if (new URL(url, URL_BASE).pathname !== pathname) return;
+    if (visitId !== undefined && visitId === followedVisitId) return;
+    const isLink = isLinkedVisit({
+      query,
+      isLinkClick,
+      previousQuery: lastQuery,
+      urlScope: options.urlScope,
+      queryParamFilters: options.queryParamFilters,
+      activeView: options.activeView(),
+      activeTab: options.activeTab(),
+      canOpenView: options.canOpenView,
+      canOpenTab: options.canOpenTab,
+    });
+    if (!isLink) return;
+    followedVisitId = visitId;
+    options.follow(query);
+  };
+
+  onMounted(() => {
+    stops.push(
+      inertiaRouter.on("navigate", (event) =>
+        read(event.detail.page.url, event.detail.visitId, false),
+      ),
+      inertiaRouter.on("clientVisit", (event) => {
+        if (event.detail.replace) return;
+        read(event.detail.page.url, event.detail.visitId, true);
+      }),
+    );
+  });
+  onBeforeUnmount(() => stops.forEach((stop) => stop()));
+}

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

@@ -1,11 +1,19 @@
-import { computed, ref, watch, type ComputedRef } from "vue";
+import {
+  computed,
+  getCurrentScope,
+  onMounted,
+  onScopeDispose,
+  ref,
+  watch,
+  type ComputedRef,
+} from "vue";
 import { usePageLive } from "../../../composables/live/usePageLive";
 import type {
   PageLiveNote,
   TableViewLiveHoldOptions,
 } from "../../../types/live";
 import type { LiveGate } from "../live/currentPageLive";
-import { useScrolledPastTop } from "./useScrolledPastTop";
+import { useScrolledPastTop, useTableReached } from "./useScrolledPastTop";
 import { LIVE_HELD_AT_QUERY_KEY } from "./useTableRows";
 
 type Query = Record<string, unknown>;
@@ -18,7 +26,10 @@ export interface TableLiveHoldSignals {
   isSearching?: () => boolean;
   /** The rows are sorted otherwise than by the table's default. */
   isSorted?: () => boolean;
-  /** The table's element, whose first row `whileScrolled` follows. */
+  /**
+   * The table's element: whether it is on screen, and where its first row
+   * stands for `whileScrolled`.
+   */
   tableElement?: () => unknown;
 }
 
@@ -29,6 +40,29 @@ export type TableLiveHoldReason =
   | "sorted"
   | "scrolled";
 
+/**
+ * A table holds by itself for a reason it names, or because the user has its
+ * rows on screen (`reading`): new rows would push them down. The latter goes
+ * unsaid; the new rows wait behind the "N new · Show" pill.
+ */
+type LocalHoldReason = TableLiveHoldReason | "reading";
+
+/**
+ * How a held table counts the new rows it would show: the rows its current
+ * query (tab, search, filters) matches now, less the rows it holds. Without
+ * it the pill counts every event of the table's topic, whatever row each
+ * one is about.
+ */
+export interface TableNewRowsCounter {
+  /**
+   * The list on screen, `null` before it arrives; read again whenever it
+   * changes (a new read, another query), which counts again.
+   */
+  heldList: () => { total: number } | null | undefined;
+  /** How many rows the table's current query matches now, unbounded. */
+  countNow: (signal: AbortSignal) => Promise<number | undefined>;
+}
+
 export interface TableLiveHoldOptions {
   /** The table's `liveHold`: `true` or an object enables it. */
   liveHold: boolean | TableViewLiveHoldOptions | undefined;
@@ -40,12 +74,16 @@ export interface TableLiveHoldOptions {
    */
   gate: () => LiveGate;
   signals?: TableLiveHoldSignals;
+  newRows?: TableNewRowsCounter;
 }
 
 export interface TableLiveHold {
   /** The rows are held: the page is paused, or the table holds by itself. */
   isHolding: ComputedRef<boolean>;
-  /** Events the table received since its rows were held or last shown. */
+  /**
+   * The rows the table would add since its rows were held or last shown
+   * (`newRows`), or else the events it received meanwhile.
+   */
   newCount: ComputedRef<number>;
   /**
    * Why the table holds by itself while its page is live, `null` otherwise:
@@ -77,22 +115,26 @@ function holdOptionsOf(
 }
 
 // The table alone holds while the page is live: the user reads a row in the
-// side panel, narrows or reorders the rows, or reads further down than the
-// rows that would move. The first reason in this order is the one shown.
+// side panel, narrows or reorders the rows, reads further down than the rows
+// that would move, or has them on screen at all — a new row at the top would
+// push them down. The first reason in this order is the one shown.
 function useLocalHold(
   holdOptions: TableViewLiveHoldOptions | null,
   signals: TableLiveHoldSignals,
-): ComputedRef<TableLiveHoldReason | null> {
+): ComputedRef<LocalHoldReason | null> {
   const tableElement = signals.tableElement ?? NO_ELEMENT;
-  const isScrolled = useScrolledPastTop(() => {
-    const element = tableElement();
-    return element instanceof HTMLElement ? element : null;
-  }, !!holdOptions?.whileScrolled);
-  const reasons: Array<[TableLiveHoldReason, boolean, () => boolean]> = [
+  const element = () => {
+    const target = tableElement();
+    return target instanceof HTMLElement ? target : null;
+  };
+  const isScrolled = useScrolledPastTop(element, !!holdOptions?.whileScrolled);
+  const isReached = useTableReached(element, !!holdOptions);
+  const reasons: Array<[LocalHoldReason, boolean, () => boolean]> = [
     ["rowOpen", !!holdOptions?.whileRowOpen, signals.isRowOpen ?? NEVER],
     ["searching", !!holdOptions?.whileSearching, signals.isSearching ?? NEVER],
     ["sorted", !!holdOptions?.whileSorted, signals.isSorted ?? NEVER],
     ["scrolled", !!holdOptions?.whileScrolled, () => isScrolled.value],
+    ["reading", !!holdOptions, () => isReached.value],
   ];
   return computed(
     () =>
@@ -102,10 +144,11 @@ function useLocalHold(
 }
 
 /**
- * The `liveHold` of a table view: while its live page is paused — or, with
- * `whileRowOpen` / `whileSearching` / `whileSorted` / `whileScrolled`, while
- * the user reads a row, searches, sorts or scrolled down — the table keeps
- * its rows: the gate requests nothing on its events and counts them, and a
+ * The `liveHold` of a table view: while its live page is paused, while its
+ * rows are on screen or scrolled past (rows landing at the top would move
+ * them) — or, with `whileRowOpen` / `whileSearching` / `whileSorted` /
+ * `whileScrolled`, saying so, while the user reads a row, searches, sorts or
+ * scrolled down — the table keeps its rows: the gate requests nothing on its events and counts them, and a
  * source route is told the moment they were frozen, so the user's own
  * search, sort and pagination list the rows as they stood.
  * Show reads them once more without leaving the hold; the end of a hold of
@@ -132,16 +175,19 @@ export function useTableLiveHold(options: TableLiveHoldOptions): TableLiveHold {
     },
     { flush: "sync" },
   );
-  const newCount = computed(() =>
-    isHolding.value ? options.gate().missed.value : 0,
-  );
+  const missed = () => (isHolding.value ? options.gate().missed.value : 0);
+  const newCount = options.newRows
+    ? useCountedNewRows(missed, options.newRows)
+    : computed(missed);
 
   return {
     isHolding,
     newCount,
-    reason: computed(() =>
-      isHolding.value && !isPaused.value ? localReason.value : null,
-    ),
+    reason: computed(() => {
+      if (!isHolding.value || isPaused.value) return null;
+      const reason = localReason.value;
+      return reason === "reading" ? null : reason;
+    }),
     missedLabel: holdOptions?.missedLabel,
     missedDetail: computed(() =>
       isPaused.value && newCount.value > 0 ? missedDetail.value : null,
@@ -151,6 +197,73 @@ export function useTableLiveHold(options: TableLiveHoldOptions): TableLiveHold {
   };
 }
 
+/** Lets a burst of events through before counting the new rows once. */
+const NEW_ROWS_COUNT_DELAY_MS = 500;
+
+// The new rows the table would show, counted on its source while it holds
+// some events: a topic publishes on every row, so a "4xx" tab, a search or a
+// filter would otherwise announce rows it never lists. Counted again on each
+// new event or held list, a burst at a time. Rows removed meanwhile lower
+// the count: the table answers what it lists, not what came in. A count that
+// fails falls back to the events. Only in the browser, once mounted: the
+// table sets up its gate and its list after its hold.
+function useCountedNewRows(
+  missed: () => number,
+  counter: TableNewRowsCounter,
+): ComputedRef<number> {
+  const counted = ref(0);
+  const hasFailed = ref(false);
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let inFlight: AbortController | undefined;
+
+  const cancel = () => {
+    clearTimeout(timer);
+    timer = undefined;
+    inFlight?.abort();
+    inFlight = undefined;
+  };
+  const count = async () => {
+    timer = undefined;
+    const held = counter.heldList()?.total;
+    if (held === undefined) return;
+    inFlight?.abort();
+    const controller = new AbortController();
+    inFlight = controller;
+    try {
+      const now = await counter.countNow(controller.signal);
+      if (controller.signal.aborted) return;
+      hasFailed.value = now === undefined;
+      counted.value = Math.max(0, (now ?? held) - held);
+    } catch {
+      if (!controller.signal.aborted) hasFailed.value = true;
+    }
+  };
+
+  const scope = getCurrentScope();
+  const follow = () =>
+    watch(
+      [missed, counter.heldList],
+      ([events]) => {
+        if (events === 0) {
+          cancel();
+          counted.value = 0;
+          hasFailed.value = false;
+          return;
+        }
+        timer ??= setTimeout(count, NEW_ROWS_COUNT_DELAY_MS);
+      },
+      { immediate: true },
+    );
+  onMounted(() => scope?.run(follow));
+  onScopeDispose(cancel);
+
+  return computed(() => {
+    const events = missed();
+    if (events === 0) return 0;
+    return hasFailed.value ? events : counted.value;
+  });
+}
+
 // The bound a source route receives while the rows are held: they are as
 // fresh as the hold, or as the last read the user asked for since (Show, an
 // action of theirs).

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

@@ -11,7 +11,8 @@ import {
   resolveUrlVariables,
 } from "../../utils/urlVariables";
 import type { RowActionRule } from "#dms-core/app/types/row-action";
-import { pinRows } from "./utils/pinnedRows";
+import { compareValues, textOf } from "./utils/compareValues";
+import { pinRows, pinRowsBySpan } from "./utils/pinnedRows";
 import {
   appendPeriodToUrl,
   usePeriodScope,
@@ -86,18 +87,6 @@ export function sourceRouteQuery(
   );
 }
 
-const textOf = (value: unknown): string =>
-  value === null || value === undefined
-    ? ""
-    : typeof value === "object"
-      ? JSON.stringify(value)
-      : String(value);
-
-const compareValues = (a: unknown, b: unknown): number => {
-  if (typeof a === "number" && typeof b === "number") return a - b;
-  return textOf(a).localeCompare(textOf(b), undefined, { numeric: true });
-};
-
 /**
  * The rows the browser narrows, sorts and pages itself, for what the source
  * route left to it: a search over the listed columns' text, the sort on one
@@ -155,7 +144,10 @@ interface SharedRead<T> {
  * order its keys were built in.
  */
 const sourceReadKey = (url: string, query: Query): string =>
-  JSON.stringify([url, Object.entries(query).sort(([a], [b]) => a.localeCompare(b))]);
+  JSON.stringify([
+    url,
+    Object.entries(query).sort(([a], [b]) => a.localeCompare(b)),
+  ]);
 
 /**
  * Settles with `answer`, or rejects as soon as `signal` aborts, calling
@@ -173,9 +165,9 @@ function awaitUnlessAborted<R>(
     };
     if (signal.aborted) return abort();
     signal.addEventListener("abort", abort, { once: true });
-    answer.then(resolve, reject).finally(() =>
-      signal.removeEventListener("abort", abort),
-    );
+    answer
+      .then(resolve, reject)
+      .finally(() => signal.removeEventListener("abort", abort));
   });
 }
 
@@ -294,19 +286,57 @@ export function useTableRows<T extends Record<string, unknown>>(
   ): 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,
+  ): Promise<TableViewListResponse<T> | null> =>
+    source
+      ? 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,
   ): Promise<TableViewListResponse<T> | null> =>
-    withPinnedRows(
-      source
-        ? await listFromSource(source, query, signal)
-        : await api<TableViewListResponse<T>>(`${location}/list`, {
-            query,
-            signal,
-          }),
-    );
+    withPinnedRows(await listAnswered(query, signal));
+
+  /**
+   * The rows `query.offset` and `query.limit` name, in the order a table
+   * reading `span` rows at a time from the first shows them: the pinned
+   * rows lead each of its reads (a page), not the rows read here. The reads
+   * they fall in are read whole, then each pinned on its own. A source
+   * answering every row pins them all before its pages are cut: as `list`.
+   */
+  const listAsShown = async (
+    query: Query,
+    span: number,
+  ): Promise<TableViewListResponse<T> | null> => {
+    const pinnedRows = options.pinnedRows?.();
+    const offset = Number(query.offset) || 0;
+    const limit = Number(query.limit) || 0;
+    const isWholeSource = !!source && !source.capabilities.paginate;
+    if (!pinnedRows || span <= 0 || limit <= 0 || isWholeSource) {
+      return list(query);
+    }
+    const start = Math.floor(offset / span) * span;
+    const end = Math.ceil((offset + limit) / span) * span;
+    const page = await listAnswered({
+      ...query,
+      offset: start,
+      limit: end - start,
+    });
+    if (!page) return null;
+    const shown = pinRowsBySpan(page.results, span, pinnedRows);
+    const from = offset - start;
+    return {
+      ...page,
+      results: shown.slice(from, from + limit),
+      offset,
+      limit,
+    };
+  };
 
   // A source answers its totals one list at a time.
   const countBatch = async (
@@ -358,6 +388,7 @@ export function useTableRows<T extends Record<string, unknown>>(
     sourceUrl,
     isPeriodPending,
     list,
+    listAsShown,
     countBatch,
     getRow,
   };

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

@@ -5,7 +5,10 @@ import {
   type FormPageUrls,
 } from "./useTableViewConfig";
 import type { FormProps } from "../../../composables/form/types";
-import type { QueryParamFilters } from "../../../composables/table-view/types";
+import type {
+  QueryParamFilters,
+  TableViewColumn,
+} from "../../../composables/table-view/types";
 import type { LocationQuery, LocationQueryValue } from "#dms/frontend-module";
 import {
   TableRowAction,
@@ -33,7 +36,7 @@ import {
   type BulkActionOutcome,
   type ConfirmedBulkAction,
 } from "./utils/bulkActions";
-import { resolveActionError } from "../confirm/actionError";
+import { describeTableWriteError } from "./utils/writeError";
 import {
   ConfirmActionError,
   type ConfirmOptions,
@@ -44,6 +47,7 @@ import {
   resolveFormContainerTexts,
   type TableViewFormKind,
 } from "./utils/formTexts";
+import { dmsOwnDrawer } from "../containers/context";
 
 const DEFAULT_ROW_ID_KEY = "_id";
 const DEFAULT_MODAL_SIZE = "xl";
@@ -58,6 +62,8 @@ const getItemId = (
 interface TableRowActionsConfig {
   api: ReturnType<typeof $fetch.create>;
   location: string;
+  /** The columns, whose labels name the fields a refused write lacks. */
+  columns: ReadonlyArray<Pick<TableViewColumn, "accessorKey" | "header">>;
   caption?: string;
   labelKey?: string;
   rowIdKey?: string;
@@ -95,6 +101,12 @@ type ConfirmedRun = NonNullable<ConfirmOptions["onConfirm"]>;
 /** Options of a delete: from the archive, it is a permanent one. */
 interface DeleteRowsOptions {
   permanently?: boolean;
+  /**
+   * The rows deleted, when the caller holds them: a dialog naming the row
+   * (`{name}`) reads its fields here first. A kanban card is not among the
+   * rows the table shows.
+   */
+  rows?: Data[];
 }
 
 export const useTableRowActions = <T extends Data>(
@@ -139,7 +151,12 @@ export const useTableRowActions = <T extends Data>(
       color: Color.error,
       icon: "i-ph-warning-circle",
       title: title || t("dms.form.error_title"),
-      description: resolveActionError(error, t),
+      description: describeTableWriteError(
+        error,
+        t,
+        config.columns,
+        processI18n,
+      ),
     });
   };
 
@@ -249,24 +266,26 @@ export const useTableRowActions = <T extends Data>(
     fetchUrl?: string,
     submitDefaults?: Record<string, unknown>,
   ) => {
-    const drawer = openDrawer({
-      title,
-      description,
-      containerId,
-      component: DmsForm,
-      componentOptions: {
-        ...processedOptions,
-        ...(fetchUrl && { fetchUrl }),
-        ...(submitDefaults && { submitDefaults }),
-        componentId: `${config.componentId}-${componentIdSuffix}`,
-        pageId: pageIdSuffix,
+    const drawer = openDrawer(
+      dmsOwnDrawer({
+        title,
+        description,
         containerId,
-        onSuccessCallback: () => {
-          drawer.close();
-          config.refreshCallback?.();
+        component: DmsForm,
+        componentOptions: {
+          ...processedOptions,
+          ...(fetchUrl && { fetchUrl }),
+          ...(submitDefaults && { submitDefaults }),
+          componentId: `${config.componentId}-${componentIdSuffix}`,
+          pageId: pageIdSuffix,
+          containerId,
+          onSuccessCallback: () => {
+            drawer.close();
+            config.refreshCallback?.();
+          },
         },
-      },
-    });
+      }),
+    );
     return drawer;
   };
 
@@ -654,38 +673,65 @@ export const useTableRowActions = <T extends Data>(
     };
   };
 
-  const findShownRow = (id: string | undefined): Data | undefined =>
-    config.rowNavigation
-      ?.rows()
-      .find(
-        (row) =>
-          String(getItemId(row, config.rowIdKey ?? DEFAULT_ROW_ID_KEY)) === id,
-      );
+  const rowIdOf = (row: Data): string =>
+    String(getItemId(row, config.rowIdKey ?? DEFAULT_ROW_ID_KEY));
+
+  const findRowIn = (rows: Data[] | undefined, id: string) =>
+    rows?.find((row) => rowIdOf(row) === id);
+
+  // A row the table does not show (a kanban card, a row deleted from a
+  // custom card) is read by id: a `from` dialog asks the server instead.
+  const readRow = async (
+    id: string,
+    declared: ActionConfirm,
+  ): Promise<Data | undefined> => {
+    const getRow = config.rowNavigation?.getRow;
+    if (!getRow || isConfirmFrom(declared)) return undefined;
+    return getRow(id).catch(() => undefined);
+  };
+
+  /** The one row a dialog words: the caller's, the table's, else read. */
+  const findConfirmRow = async (
+    id: string,
+    declared: ActionConfirm,
+    rows?: Data[],
+  ): Promise<Data | undefined> =>
+    findRowIn(rows, id) ??
+    findRowIn(config.rowNavigation?.rows(), id) ??
+    (await readRow(id, declared));
 
   /**
-   * What a fixed dialog words: the rows' count, and for one row shown in the
-   * table its own fields too (`{name}`). The count wins a clash, it is what
-   * every bulk dialog may name.
+   * What a fixed dialog words: the rows' count, and for one row its own
+   * fields too (`{name}`). The count wins a clash, it is what every bulk
+   * dialog may name.
    */
-  const confirmRowFields = (ids: string[]): Data => {
+  const confirmRowFields = async (
+    ids: string[],
+    declared: ActionConfirm,
+    rows?: Data[],
+  ): Promise<Data> => {
     const count = { count: ids.length };
-    const row = ids.length === 1 ? findShownRow(ids[0]) : undefined;
+    const row =
+      ids.length === 1
+        ? await findConfirmRow(ids[0]!, declared, rows)
+        : undefined;
     return row ? { ...row, ...count } : count;
   };
 
   /** Asks the declared confirmation of a bulk action, running it inside. */
-  const askDeclaredBulkConfirm = (
+  const askDeclaredBulkConfirm = async (
     declared: ActionConfirm,
     ids: string[],
     fallback: Partial<ConfirmOptions>,
     run: ConfirmedRun,
+    rows?: Data[],
   ): Promise<boolean> =>
     confirmAction(declared, {
       urlParams: {
         id: ids[0],
         [config.rowIdKey ?? DEFAULT_ROW_ID_KEY]: ids[0],
       },
-      row: confirmRowFields(ids),
+      row: await confirmRowFields(ids, declared, rows),
       fallback,
       run,
     });
@@ -703,11 +749,14 @@ export const useTableRowActions = <T extends Data>(
     actionConfig: boolean | RowActionConfig | undefined,
     action: ConfirmedBulkAction,
     bulkConfig: BulkActionConfig,
+    rows?: Data[],
   ): Promise<boolean> => {
     const fallback = bulkActionConfirm(action, ids.length, t);
     const run = bulkActionRun(ids, actionConfig, bulkConfig);
     const declared = declaredBulkConfirm(actionConfig, ids);
-    if (declared) return askDeclaredBulkConfirm(declared, ids, fallback, run);
+    if (declared) {
+      return askDeclaredBulkConfirm(declared, ids, fallback, run, rows);
+    }
     return confirm({ ...fallback, onConfirm: run });
   };
 
@@ -746,7 +795,13 @@ export const useTableRowActions = <T extends Data>(
   ): Promise<boolean> => {
     if (!normalizeActionConfig(deleteConfig).isEnabled) return false;
     const action = options.permanently ? "deletePermanently" : "delete";
-    return confirmBulkAction(ids, deleteConfig, action, DELETE_CONFIG);
+    return confirmBulkAction(
+      ids,
+      deleteConfig,
+      action,
+      DELETE_CONFIG,
+      options.rows,
+    );
   };
 
   const archiveRows = async (