@everystack/admin 0.4.3 → 0.4.4

package/src/types.ts

@@ -314,6 +314,12 @@ export interface ResourceConfig {
   editFields?: string[];
   /** Primary key field name */
   primaryKey?: string;
+  /**
+   * PostgREST select string for list, show and edit, embeds included, e.g.
+   * '*,user:users(name)'. One string for all three. Show an embedded value
+   * through a field `render`. RPC-backed resources ignore it.
+   */
+  select?: string;
   /** How the show view fetches one record. 'rpc' calls the role-gated
    *  {camelResource}EventDetail RPC (the resource stays off the REST surface);
    *  'rest' (default) uses adapter.fetchOne. Lets a plain list (no dashboard) —
@@ -328,6 +334,21 @@ export interface ResourceConfig {
   rowActions?: RowActionConfig[];
   /** Tabs above the list, each a named filter. Without this the list shows no tabs. */
   scopes?: ScopeConfig[];
+  /**
+   * The table soft-deletes. Turns on Restore for deleted rows (in a scope with
+   * `deleted: 'only'`, and on Show) and makes Show load a deleted row. Delete
+   * stays shown unless `actions.delete` is false.
+   */
+  softDelete?: {
+    /** The soft-delete column, as the API names it. Default 'deletedAt'. */
+    column?: string;
+  };
+  /**
+   * Rows in other tables that point at this record. Before a delete, Show lists
+   * each one with a count of the linked rows (one request each, at most 12).
+   * Without it, Delete works as before.
+   */
+  associations?: AssociationConfig[];
   /**
    * Show a row count on each tab. Off unless set: counts cost queries. The values of one
    * enum column share one grouped query; every other tab costs one count. Counts follow the
@@ -564,6 +585,24 @@ export interface AdminConfig {
 // Data Types
 // =============================================================================
 
+/**
+ * A table that links to a record, counted in the delete preview. A polymorphic
+ * link (`resource_id` + `resource_type`, often with no foreign key) sets
+ * `typeColumn` and `typeValue` as well.
+ */
+export interface AssociationConfig {
+  /** Shown in the preview, e.g. 'Bookmarks'. */
+  label: string;
+  /** The related table or resource name, as the adapter knows it. */
+  resource: string;
+  /** The column on the related table that holds this record's id. */
+  foreignKey: string;
+  /** The polymorphic type column on the related table, e.g. 'resource_type'. */
+  typeColumn?: string;
+  /** The value of `typeColumn` that means this resource, e.g. 'Content'. */
+  typeValue?: string;
+}
+
 /**
  * A named filter shown as a tab above a list ("Current", "Draft"). Scopes are
  * ANDed with the search and any column filters.
@@ -576,8 +615,13 @@ export interface ScopeConfig {
   filter?: Record<string, unknown>;
   /** The scope active when the URL names none. If none is marked, the first is. */
   default?: boolean;
+  /** Soft-deleted rows: 'include' adds them, 'only' lists nothing else. See ListParams.deleted. */
+  deleted?: DeletedMode;
 }
 
+/** Soft-delete reads: 'include' returns live and deleted rows, 'only' deleted rows. */
+export type DeletedMode = 'include' | 'only';
+
 export interface ListParams {
   /** Page number (1-indexed) */
   page?: number;
@@ -597,6 +641,17 @@ export interface ListParams {
    * returning unfiltered rows. Plain column names only.
    */
   searchFields?: string[];
+  /**
+   * PostgREST select string, embeds included, e.g. '*,user:users(name)'.
+   * Passed verbatim to the query builder. Ignored by RPC-backed resources
+   * (listRpcs); an RPC decides its own shape.
+   */
+  select?: string;
+  /**
+   * Soft-deleted rows, sent as `?deleted=` to the API. RPC-backed resources
+   * get it in the RPC body, and the RPC owner decides.
+   */
+  deleted?: DeletedMode;
 }
 
 export interface ListResult<T = Record<string, unknown>> {
@@ -643,6 +698,8 @@ export interface AggregateParams {
   search?: string;
   /** Columns `search` looks in. Required with `search`. Plain column names only. */
   searchFields?: string[];
+  /** Soft-deleted rows, exactly as `ListParams.deleted`, so a Deleted tab counts deleted rows. */
+  deleted?: DeletedMode;
 }
 
 export interface AggregateResult {

package/src/utils/list-query.ts

@@ -15,7 +15,7 @@
  */
 
 import type { ViewParams } from '../hooks/useViewState';
-import type { ListParams } from '../types';
+import type { DeletedMode, ListParams } from '../types';
 
 /** Longest search text kept. A pasted paragraph is not a search. */
 export const MAX_SEARCH_LENGTH = 200;
@@ -86,15 +86,15 @@ export function parseListQuery(params: ViewParams): ListQuery {
 /**
  * List state → a `setParams` delta. Every key is present, so a cleared field
  * removes its key from the URL. Defaults (page 1, no search, the resource's
- * `defaultPerPage`) are not written.
+ * `defaultPerPage` and `defaultScope`) are not written.
  */
 export function listQueryToParams(
   query: ListQuery,
-  options: { defaultPerPage?: number } = {},
+  options: { defaultPerPage?: number; defaultScope?: string } = {},
 ): Record<string, string | undefined> {
   return {
     q: query.search || undefined,
-    tab: query.scope || undefined,
+    tab: query.scope && query.scope !== options.defaultScope ? query.scope : undefined,
     sort: query.sort || undefined,
     dir: query.order,
     page: query.page && query.page > 1 ? String(query.page) : undefined,
@@ -145,6 +145,8 @@ export interface BuildListParamsOptions {
   baseFilter?: Record<string, unknown>;
   /** The active scope's filter, already resolved from the scope id. */
   scopeFilter?: Record<string, unknown>;
+  /** The active scope's `deleted`, copied into ListParams beside the filter. */
+  scopeDeleted?: DeletedMode;
   /** Columns a user may sort by. A sort outside this set is dropped. */
   sortableFields?: ReadonlySet<string>;
   /** Used when the query has no valid sort of its own. */
@@ -172,6 +174,7 @@ export function buildListParams(query: ListQuery, options: BuildListParamsOption
     sort,
     order,
     filter: mergeFilters(options.baseFilter, options.scopeFilter),
+    ...(options.scopeDeleted ? { deleted: options.scopeDeleted } : {}),
   };
 }
 

package/src/utils/scope-counts.ts

@@ -21,6 +21,8 @@ export interface ScopeCountPlan {
 
 /** `{ 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];

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/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(',');
   }