@everystack/admin 0.4.2 → 0.4.4

package/src/utils/scope-counts.ts

@@ -0,0 +1,65 @@
+/**
+ * Scope counts, planned. Tabs that are the values of one enum column (`state: 'eq.draft'`,
+ * `state: 'eq.published'`) share ONE grouped query; every other tab costs one count of its
+ * own. Pure, so the hook only has to run the plan.
+ */
+
+import type { ScopeConfig } from '../types';
+
+/** One grouped query: count rows by `column`, then hand each value's count to its tab. */
+export interface GroupedCount {
+  column: string;
+  /** Column value -> id of the tab that shows it. */
+  scopeIdByValue: Record<string, string>;
+}
+
+export interface ScopeCountPlan {
+  grouped: GroupedCount[];
+  /** Tabs that need a count query of their own, in the order given. */
+  single: ScopeConfig[];
+}
+
+/** `{ state: 'eq.draft' }` is the one shape that can ride a grouped query. */
+function equality(scope: ScopeConfig): { column: string; value: string } | null {
+  // The grouped query reads live rows only, so a scope over deleted rows counts alone.
+  if (scope.deleted) return null;
+  const entries = Object.entries(scope.filter ?? {});
+  if (entries.length !== 1) return null;
+  const [column, raw] = entries[0];
+  if (typeof raw !== 'string' || !raw.startsWith('eq.') || raw.length === 3) return null;
+  return { column, value: raw.slice(3) };
+}
+
+export function planScopeCounts(scopes: ScopeConfig[]): ScopeCountPlan {
+  const byColumn = new Map<string, Array<{ scope: ScopeConfig; value: string }>>();
+  for (const scope of scopes) {
+    const eq = equality(scope);
+    if (!eq) continue;
+    const members = byColumn.get(eq.column) ?? [];
+    // Two tabs on one value cannot share a row of the answer: the later one counts alone.
+    if (!members.some(m => m.value === eq.value)) members.push({ scope, value: eq.value });
+    byColumn.set(eq.column, members);
+  }
+
+  const grouped: GroupedCount[] = [];
+  const inGroup = new Set<ScopeConfig>();
+  for (const [column, members] of byColumn) {
+    if (members.length < 2) continue;
+    grouped.push({
+      column,
+      scopeIdByValue: Object.fromEntries(members.map(m => [m.value, m.scope.id])),
+    });
+    for (const m of members) inGroup.add(m.scope);
+  }
+  return { grouped, single: scopes.filter(scope => !inGroup.has(scope)) };
+}
+
+/** Each tab of the group gets its value's count; a value with no rows is zero, not missing. */
+export function countsFromGrouped(rows: Record<string, unknown>[], group: GroupedCount): Record<string, number> {
+  const counts = Object.fromEntries(Object.values(group.scopeIdByValue).map(id => [id, 0]));
+  for (const row of rows) {
+    const id = group.scopeIdByValue[String(row[group.column])];
+    if (id !== undefined) counts[id] = Number(row.count ?? 0);
+  }
+  return counts;
+}

package/src/utils/scopes.ts

@@ -0,0 +1,38 @@
+/**
+ * Scope rules: which scope is active, and building scope tabs from an enum.
+ * Pure, so the list screen only has to render the answer.
+ */
+
+import type { FieldDefinition, ScopeConfig } from '../types';
+
+/**
+ * The active scope: the one the URL names; else the one marked default (the
+ * first, if several are); else the first scope. A URL naming a scope that no
+ * longer exists falls back the same way, so an old link still opens a list.
+ */
+export function resolveScope(scopes: ScopeConfig[] | undefined, id: string | undefined): ScopeConfig | undefined {
+  if (!scopes || scopes.length === 0) return undefined;
+  return (
+    scopes.find(scope => scope.id === id) ??
+    scopes.find(scope => scope.default) ??
+    scopes[0]
+  );
+}
+
+/** `in_review` → `In review`. */
+const labelFor = (value: string): string => {
+  const words = value.replace(/_/g, ' ');
+  return words.charAt(0).toUpperCase() + words.slice(1);
+};
+
+/** One scope per value of an enum field, filtering on equality. Combine with other scopes in the config. */
+export function enumScopes(field: FieldDefinition): ScopeConfig[] {
+  if (!field.enumValues || field.enumValues.length === 0) {
+    throw new Error(`enumScopes needs an enum field with enumValues; "${field.name}" has none`);
+  }
+  return field.enumValues.map(value => ({
+    id: value,
+    label: labelFor(value),
+    filter: { [field.name]: `eq.${value}` },
+  }));
+}

package/src/utils/standard-actions.ts

@@ -6,6 +6,9 @@
  * the same actions column as custom rowActions and share the confirm/busy/error
  * chrome. Show/Edit navigate via the supplied callbacks; Delete self-serves
  * through adapter.delete and lets RowActionButton refetch afterward.
+ *
+ * In a scope with `deleted: 'only'` the rows are soft-deleted: Edit and Delete
+ * are hidden, and a resource that declares `softDelete` gets Restore instead.
  */
 
 import type { ResourceConfig, RowActionConfig, DataRecord } from '../types';
@@ -15,32 +18,65 @@ export interface StandardActionNav {
   onShow?: (record: DataRecord) => void;
   /** Navigate to the record's edit screen. */
   onEdit?: (record: DataRecord) => void;
+  /**
+   * Navigate to the record's Show with its delete preview open. Used by Delete
+   * when the resource declares `associations`; without it Delete keeps its two taps.
+   */
+  onConfirmDelete?: (record: DataRecord) => void;
+}
+
+const idOf = (resourceConfig: ResourceConfig, record: DataRecord): string | number =>
+  (record[resourceConfig.primaryKey ?? 'id'] as string | number) ?? (record.id as string | number);
+
+/** The soft-delete column of a resource that declares `softDelete`, else undefined. */
+export function softDeleteColumn(resourceConfig: ResourceConfig): string | undefined {
+  return resourceConfig.softDelete ? resourceConfig.softDelete.column ?? 'deletedAt' : undefined;
+}
+
+/** Restore a soft-deleted row: clear its column, matching deleted rows only. Undefined without `softDelete`. */
+export function restoreAction(resourceConfig: ResourceConfig): RowActionConfig | undefined {
+  const column = softDeleteColumn(resourceConfig);
+  if (!column) return undefined;
+  return {
+    id: '__restore',
+    label: 'Restore',
+    variant: 'outline',
+    confirm: 'Confirm restore',
+    onPress: async ({ record, adapter }) => {
+      await adapter.update(resourceConfig.name, idOf(resourceConfig, record), { [column]: null }, { deleted: 'only' });
+    },
+  };
 }
 
 export function standardRowActions(
   resourceConfig: ResourceConfig,
   nav: StandardActionNav,
+  scope: { deletedOnly?: boolean } = {},
 ): RowActionConfig[] {
   const actions = resourceConfig.actions ?? {};
-  const primaryKey = resourceConfig.primaryKey ?? 'id';
-  const idOf = (record: DataRecord): string | number =>
-    (record[primaryKey] as string | number) ?? (record.id as string | number);
 
   const out: RowActionConfig[] = [];
 
   if (actions.show !== false && nav.onShow) {
     out.push({ id: '__show', label: 'Show', variant: 'outline', onPress: ({ record }) => nav.onShow!(record) });
   }
+  if (scope.deletedOnly) {
+    const restore = restoreAction(resourceConfig);
+    if (restore) out.push(restore);
+    return out;
+  }
   if (actions.edit !== false && nav.onEdit) {
     out.push({ id: '__edit', label: 'Edit', variant: 'outline', onPress: ({ record }) => nav.onEdit!(record) });
   }
-  if (actions.delete !== false) {
+  if (actions.delete !== false && resourceConfig.associations?.length && nav.onConfirmDelete) {
+    out.push({ id: '__delete', label: 'Delete', variant: 'destructive', onPress: ({ record }) => nav.onConfirmDelete!(record) });
+  } else if (actions.delete !== false) {
     out.push({
       id: '__delete',
       label: 'Delete',
       variant: 'destructive',
       confirm: 'Confirm delete',
-      onPress: ({ record, adapter }) => adapter.delete(resourceConfig.name, idOf(record)),
+      onPress: ({ record, adapter }) => adapter.delete(resourceConfig.name, idOf(resourceConfig, record)),
     });
   }
 

package/src/utils/tags.ts

@@ -0,0 +1,40 @@
+/**
+ * Value handling for `type: 'tags'` fields (a text[] column).
+ *
+ * The rule is: never drop or reorder a stored value implicitly. A toggle adds
+ * or removes the one value pressed and leaves the rest of the array as it was.
+ */
+
+import type { FieldDefinition } from '../types';
+
+/** The stored value as a string array. null/undefined is []; a lone scalar is kept as one value. */
+export function tagValues(value: unknown): string[] {
+  if (value == null) return [];
+  if (Array.isArray(value)) return value.map(v => String(v));
+  return [String(value)];
+}
+
+/** Add `tag` when absent (at the end), remove it when present. Every other value keeps its place. */
+export function toggleTag(values: readonly string[], tag: string): string[] {
+  return values.includes(tag) ? values.filter(v => v !== tag) : [...values, tag];
+}
+
+/** Every value the field's groups list. */
+function listedTags(field: FieldDefinition): Set<string> {
+  return new Set((field.tagGroups ?? []).flatMap(g => g.options.map(o => o.value)));
+}
+
+/** The label of `tag` from the field's groups, or the raw value when no group lists it. */
+export function tagLabel(field: FieldDefinition, tag: string): string {
+  for (const group of field.tagGroups ?? []) {
+    const option = group.options.find(o => o.value === tag);
+    if (option) return option.label ?? option.value;
+  }
+  return tag;
+}
+
+/** Stored values no group lists, first occurrence order, once each. */
+export function unlistedTags(field: FieldDefinition, values: readonly string[]): string[] {
+  const listed = listedTags(field);
+  return [...new Set(values.filter(v => !listed.has(v)))];
+}

package/src/utils/view-filters.ts

@@ -15,6 +15,7 @@ export function paramsToFilters(params: ViewParams, dimensions: DimensionConfig[
   const filters: DashboardFilters = {};
   if (params.from && params.to) filters.time = [params.from, params.to];
   for (const dim of dimensions) {
+    if (RESERVED_PARAMS.has(dim.column)) continue;
     const v = params[dim.column];
     if (v) filters[dim.column] = v.split(',');
   }
@@ -24,12 +25,13 @@ export function paramsToFilters(params: ViewParams, dimensions: DimensionConfig[
 /** Analytics filters → a query-param delta that clears then sets controlled keys. */
 export function filtersToParams(filters: DashboardFilters, dimensions: DimensionConfig[]): Record<string, string | undefined> {
   const update: Record<string, string | undefined> = { from: undefined, to: undefined };
-  for (const dim of dimensions) update[dim.column] = undefined;
+  for (const dim of dimensions) if (!RESERVED_PARAMS.has(dim.column)) update[dim.column] = undefined;
   if (filters.time && filters.time[0] && filters.time[1]) {
     update.from = filters.time[0];
     update.to = filters.time[1];
   }
   for (const dim of dimensions) {
+    if (RESERVED_PARAMS.has(dim.column)) continue;
     const v = filters[dim.column] as string[] | undefined;
     if (v && v.length) update[dim.column] = v.join(',');
   }
@@ -37,7 +39,7 @@ export function filtersToParams(filters: DashboardFilters, dimensions: Dimension
 }
 
 /** Query params reserved for view state (not column filters). */
-const RESERVED_PARAMS = new Set(['from', 'to', 'sort', 'order', 'page', 'q']);
+export const RESERVED_PARAMS: ReadonlySet<string> = new Set(['from', 'to', 'sort', 'dir', 'page', 'size', 'q', 'tab']);
 
 /**
  * Pass-through column filters: any query param that names a real resource field