@tinya-code/gas-admin-ui 0.2.0-alpha.13 → 0.2.0-alpha.15

package/ng-package.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/gas-admin-ui",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tinya-code/gas-admin-ui",
-  "version": "0.2.0-alpha.13",
+  "version": "0.2.0-alpha.15",
   "description": "Motor de render Angular para admin CRUD: declará ResourceSchema y el motor dibuja vistas, campos y widgets.",
   "repository": {
     "type": "git",
@@ -28,17 +28,5 @@
   "dependencies": {
     "tslib": "^2.3.0"
   },
-  "sideEffects": false,
-  "module": "fesm2022/tinya-code-gas-admin-ui.mjs",
-  "typings": "types/tinya-code-gas-admin-ui.d.ts",
-  "exports": {
-    "./package.json": {
-      "default": "./package.json"
-    },
-    ".": {
-      "types": "./types/tinya-code-gas-admin-ui.d.ts",
-      "default": "./fesm2022/tinya-code-gas-admin-ui.mjs"
-    }
-  },
-  "type": "module"
-}
+  "sideEffects": false
+}

package/src/lib/actions/action-registry.spec.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  actionType,
+  actionsFor,
+  getAction,
+  registerAction,
+  type ActionDescriptor,
+} from './action-registry';
+
+function descriptor(
+  type: string,
+  surfaces: ActionDescriptor['surfaces'] = ['row'],
+): ActionDescriptor {
+  return { type, surfaces, run: async () => ({ ok: true }) };
+}
+
+describe('action-registry', () => {
+  it('registra un descriptor y lo devuelve por su tipo', () => {
+    registerAction(descriptor('compartir'));
+    expect(getAction('compartir')?.type).toBe('compartir');
+  });
+
+  it('devuelve undefined para un tipo sin registrar', () => {
+    expect(getAction('sin-registrar')).toBeUndefined();
+  });
+
+  it('al re-registrar un tipo reemplaza el descriptor anterior', () => {
+    registerAction(descriptor('navegar', ['detail']));
+    registerAction(descriptor('navegar', ['row', 'detail']));
+    expect(getAction('navegar')?.surfaces).toEqual(['row', 'detail']);
+  });
+
+  it('lista sólo los descriptores cuya superficie coincide', () => {
+    registerAction(descriptor('cabecera', ['header']));
+    expect(actionsFor('header').map((d) => d.type)).toEqual(['cabecera']);
+    expect(actionsFor('bulk')).toEqual([]);
+  });
+});
+
+describe('actionType', () => {
+  it('usa el tipo declarado', () => {
+    expect(actionType({ id: 'x', label: 'X', type: 'trigger' })).toBe('trigger');
+    expect(actionType({ id: 'x', label: 'X', type: 'copy-share', urlTemplate: '/p/{ref}' })).toBe(
+      'copy-share',
+    );
+  });
+
+  it('una acción sin type es una navegación (NavigateAction.type es opcional)', () => {
+    expect(actionType({ id: 'x', label: 'X', urlTemplate: '/p/{ref}' })).toBe('navigate');
+  });
+});

package/src/lib/actions/action-registry.ts

@@ -0,0 +1,126 @@
+import type { Router } from '@angular/router';
+
+import type { LucideIcon } from '@lucide/angular';
+
+import {
+  actionDescriptors,
+  isShareAction,
+  isTriggerAction,
+  resolveShare,
+  type ResolvedShare,
+} from './descriptors';
+import type { ResourceAction } from '../core/models/schema.model';
+import type { SessionUser } from '../core/services/auth.service';
+import type { ApiService } from '../core/services/api.service';
+import type { NotificationService } from '../core/services/notification.service';
+
+/**
+ * Registro único de acciones (R3.9 · `refactormotor.md`).
+ *
+ * Es el gemelo del registro de render (`core/registry/render-registry.ts`):
+ * en lugar de «qué componente pinta un tipo de campo», responde «qué
+ * comportamiento ejecuta un tipo de acción» y permite **migrar el dispatch
+ * if/copiado-pegado de las vistas (R3.11) a datos + un solo `run`**.
+ *
+ * Como los descriptores son objetos planos de módulo (no los inyecta Angular),
+ * todo lo que necesiten llegar por el `ActionContext`: los puertos (`api`,
+ * `router`, `toast`) y los datos (`record`, `resource`, `vars`).
+ */
+
+/** Superficies donde una acción puede aparecer. */
+export type ActionSurface = 'row' | 'detail' | 'header' | 'bulk' | 'post-create';
+
+/**
+ * Lo que aporta el llamador al ejecutar una acción: el registro sobre el que
+ * corre y los puertos que el descriptor usará para actuar.
+ *
+ * `record` es `null` en las superficies sin fila (`header`, `bulk`), para que
+ * un descriptor pueda distinguir «sin registro» de «registro vacío».
+ */
+export interface ActionRequest {
+  record: Record<string, unknown> | null;
+  /** Id del recurso (schema) dueño de la acción. */
+  resource: string;
+  api: ApiService;
+  router: Router;
+  toast: NotificationService;
+  user: SessionUser | null;
+  /**
+   * `keyField` del schema. **R3.12 (desviación nº 3 del contrato):** con
+   * `record` forma la clave que necesita la ruta lógica de `trigger`
+   * (`/admin/<recurso>/<key>/actions/<name>`). Lo aporta la vista, que es
+   * quien tiene el schema.
+   */
+  keyField: string;
+}
+
+/**
+ * Contexto que recibe el descriptor: la petición del llamador más el contexto
+ * de interpolación ya resuelto. `ActionService.run` lo arma, así que ninguna
+ * vista repite `buildInterpolationContext(record)`.
+ */
+export interface ActionContext extends ActionRequest {
+  /** `{...configGlobal, ...record, public_base_url}` — listo para las plantillas. */
+  vars: Record<string, unknown>;
+}
+
+/** Resultado que la vista puede leer para saber si debe recargar. */
+export interface ActionResult {
+  /** `false` cuando la acción no llegó a ejecutarse; el error ya se notificó. */
+  ok: boolean;
+  /** `true` cuando tocó datos y la vista debe recargar su listado/detalle. */
+  reload?: boolean;
+}
+
+export interface ActionDescriptor {
+  /** Clave del dispatch: el `type` del schema (`'navigate'` no lo declara). */
+  type: string;
+  /** Superficies donde esta acción puede aparecer. */
+  surfaces: ActionSurface[];
+  run: (ctx: ActionContext, action: ResourceAction) => Promise<ActionResult>;
+  /** `true` si el descriptor exige confirmación antes de ejecutar. */
+  confirm?: boolean;
+  /**
+   * Icono lucide que representa la acción donde el espacio es reducido
+   * (la fila del listado). Sin él, la vista muestra `action.label`.
+   */
+  icon?: LucideIcon;
+}
+
+export { isShareAction, isTriggerAction, resolveShare, type ResolvedShare };
+
+const ACCIONES = new Map<string, ActionDescriptor>();
+
+/** Registra (o reemplaza) un descriptor de acción. */
+export function registerAction(descriptor: ActionDescriptor): void {
+  ACCIONES.set(descriptor.type, descriptor);
+}
+
+export function getAction(type: string): ActionDescriptor | undefined {
+  return ACCIONES.get(type);
+}
+
+/** Descriptores disponibles en una superficie. */
+export function actionsFor(surface: ActionSurface): ActionDescriptor[] {
+  return [...ACCIONES.values()].filter((descriptor) => descriptor.surfaces.includes(surface));
+}
+
+/**
+ * Clave de dispatch de una acción. `NavigateAction.type` es **opcional**
+ * (schema.model.ts), así que una acción sin `type` es una navegación.
+ */
+export function actionType(action: ResourceAction): string {
+  return action.type ?? 'navigate';
+}
+
+/** Tipos registrados. Sólo para comprobaciones y tests. */
+export function actionTypes(): string[] {
+  return [...ACCIONES.keys()];
+}
+
+// Catálogo a scope de módulo: se registra al importar, sin esperar a DI,
+// igual que el registro de render (mismo motivo: `buildFormSchema()` es una
+// función pura que consulta sin inyectar nada).
+for (const descriptor of actionDescriptors) {
+  registerAction(descriptor);
+}

package/src/lib/actions/action-service.spec.ts

@@ -0,0 +1,215 @@
+import { TestBed } from '@angular/core/testing';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { ActionService } from './action-service';
+import { registerAction, type ActionContext, type ActionDescriptor } from './action-registry';
+import { actionDescriptors } from './descriptors';
+import type { ResourceAction } from '../core/models/schema.model';
+import type { ApiService } from '../core/services/api.service';
+import { ConfigService } from '../core/services/config.service';
+import type { NotificationService } from '../core/services/notification.service';
+import type { Router } from '@angular/router';
+
+/** Notificador falso: sólo el contrato que `ActionService` usa. */
+function fakeToast(): NotificationService & { confirm: ReturnType<typeof vi.fn> } {
+  return {
+    confirm: vi.fn().mockResolvedValue(true),
+    error: vi.fn(),
+    success: vi.fn(),
+    info: vi.fn(),
+    dismiss: vi.fn(),
+  } as unknown as NotificationService & { confirm: ReturnType<typeof vi.fn> };
+}
+
+function fakeRequest(toast: NotificationService) {
+  return {
+    record: { slug: 'tecla', ref: 'p1' },
+    resource: 'productos',
+    api: {} as ApiService,
+    router: { navigate: async () => true } as unknown as Router,
+    toast,
+    user: null,
+    keyField: 'ref',
+  };
+}
+
+const COMPARTIR: ResourceAction = {
+  id: 'compartir',
+  label: 'Compartir',
+  type: 'copy-share',
+  urlTemplate: 'https://demo/p/{ref}',
+};
+
+describe('ActionService', () => {
+  let service: ActionService;
+  let toast: ReturnType<typeof fakeToast>;
+  const ensureLoaded = vi.fn<() => Promise<void>>().mockResolvedValue(undefined);
+
+  beforeEach(() => {
+    toast = fakeToast();
+    ensureLoaded.mockClear();
+    ensureLoaded.mockResolvedValue(undefined);
+    TestBed.configureTestingModule({
+      providers: [
+        // ConfigService real pediría HttpClient/API_URL; sólo aporta `vars`
+        // y el reintento de config que `copy-share` dispara.
+        {
+          provide: ConfigService,
+          useValue: {
+            ensureLoaded,
+            buildInterpolationContext: (record: Record<string, unknown>) => ({
+              ...record,
+              public_base_url: 'https://demo',
+            }),
+          },
+        },
+      ],
+    });
+    service = TestBed.inject(ActionService);
+  });
+
+  // El `Map` del registro es estado de módulo **compartido entre ficheros**
+  // cuando vitest los ejecuta en el mismo worker: varios tests de éste
+  // sobrescriben `copy-share` / `navigate` / `trigger` con dobles.
+  // Sin restaurar aquí, `contract.spec` y `descriptors.spec` leen esos dobles
+  // y la suite se pone flaka **según el orden de ficheros** (falló 4 tests de
+  // `descriptors.spec` en una corrida y 0 en la siguiente, sin tocar código).
+  // Quien ensucia es quien limpia: el estado por defecto es el catálogo real.
+  afterEach(() => {
+    for (const descriptor of actionDescriptors) registerAction(descriptor);
+  });
+
+  it('ejecuta el descriptor y le entrega la petición + vars de interpolación', async () => {
+    const vistos: ActionContext[] = [];
+    registerAction({
+      type: 'copy-share',
+      surfaces: ['row', 'post-create'],
+      run: async (ctx) => {
+        vistos.push(ctx);
+        return { ok: true, reload: true };
+      },
+    });
+
+    const resultado = await service.run(COMPARTIR, fakeRequest(toast));
+
+    expect(resultado).toEqual({ ok: true, reload: true });
+    expect(vistos).toHaveLength(1);
+    expect(vistos[0].record).toEqual({ slug: 'tecla', ref: 'p1' });
+    expect(vistos[0].resource).toBe('productos');
+    expect(vistos[0].vars).toEqual({ slug: 'tecla', ref: 'p1', public_base_url: 'https://demo' });
+  });
+
+  it('copy-share reintenta la config global ANTES de resolver vars', async () => {
+    // Regresión del «mensaje = sólo la URL»: si el load del bootstrap falló,
+    // el descriptor debe ver la config ya recargada, no el snapshot vacío.
+    let ensureHecho = false;
+    ensureLoaded.mockImplementation(async () => {
+      ensureHecho = true;
+    });
+    const varsAlEjecutar: Record<string, unknown>[] = [];
+    registerAction({
+      type: 'copy-share',
+      surfaces: ['row'],
+      run: async (ctx) => {
+        expect(ensureHecho).toBe(true);
+        varsAlEjecutar.push(ctx.vars);
+        return { ok: true };
+      },
+    });
+
+    await service.run(COMPARTIR, fakeRequest(toast));
+
+    expect(ensureLoaded).toHaveBeenCalledOnce();
+    expect(varsAlEjecutar[0]).toEqual({
+      slug: 'tecla',
+      ref: 'p1',
+      public_base_url: 'https://demo',
+    });
+  });
+
+  it('acciones que no son copy-share no tocan la config', async () => {
+    const run = vi.fn<NonNullable<ActionDescriptor['run']>>().mockResolvedValue({ ok: true });
+    registerAction({ type: 'navigate', surfaces: ['row'], run });
+
+    await service.run({ id: 'ver', label: 'Ver', urlTemplate: '/p/{ref}' }, fakeRequest(toast));
+
+    expect(ensureLoaded).not.toHaveBeenCalled();
+  });
+
+  it('una acción sin type resuelve el descriptor navigate', async () => {
+    const run = vi.fn<NonNullable<ActionDescriptor['run']>>();
+    registerAction({ type: 'navigate', surfaces: ['row', 'detail'], run });
+
+    await service.run({ id: 'ver', label: 'Ver', urlTemplate: '/p/{ref}' }, fakeRequest(toast));
+
+    expect(run).toHaveBeenCalledOnce();
+  });
+
+  it('sin descriptor registrado rompe en lugar de ignorarse', async () => {
+    // `ResourceAction` es una unión cerrada y el registro es estado de
+    // módulo compartido entre tests: se fuerza un type que nadie registra
+    // (el cast a `unknown` sólo salva al compilador, no cambia el código).
+    const desconocida = { id: 'x', label: 'X', type: 'nadie' } as unknown as ResourceAction;
+    await expect(service.run(desconocida, fakeRequest(toast))).rejects.toThrow(
+      'no tiene descriptor registrado',
+    );
+  });
+
+  it('con confirmación rechazada no ejecuta y devuelve ok false', async () => {
+    toast.confirm.mockResolvedValue(false);
+    const run = vi.fn<NonNullable<ActionDescriptor['run']>>();
+    registerAction({
+      type: 'trigger',
+      surfaces: ['row'],
+      confirm: true,
+      run,
+    });
+
+    const resultado = await service.run(
+      {
+        id: 'publicar',
+        label: 'Publicar',
+        type: 'trigger',
+        confirmMessage: 'Se publicará para todos.',
+      },
+      fakeRequest(toast),
+    );
+
+    expect(toast.confirm).toHaveBeenCalledWith({
+      title: 'Publicar',
+      message: 'Se publicará para todos.',
+      confirmLabel: 'Confirmar',
+      cancelLabel: 'Cancelar',
+    });
+    expect(run).not.toHaveBeenCalled();
+    expect(resultado).toEqual({ ok: false });
+  });
+
+  it('con confirmación aceptada ejecuta el descriptor', async () => {
+    const run = vi.fn<NonNullable<ActionDescriptor['run']>>().mockResolvedValue({ ok: true });
+    registerAction({ type: 'trigger', surfaces: ['row'], confirm: true, run });
+
+    const resultado = await service.run(
+      { id: 'duplicar', label: 'Duplicar', type: 'trigger' },
+      fakeRequest(toast),
+    );
+
+    expect(run).toHaveBeenCalledOnce();
+    expect(resultado).toEqual({ ok: true });
+  });
+
+  it('un error del descriptor se notifica y no se devuelve como éxito', async () => {
+    registerAction({
+      type: 'copy-share',
+      surfaces: ['row'],
+      run: async () => {
+        throw new Error('El backend respondió 500');
+      },
+    });
+
+    const resultado = await service.run(COMPARTIR, fakeRequest(toast));
+
+    expect(toast.error).toHaveBeenCalledWith('El backend respondió 500');
+    expect(resultado).toEqual({ ok: false });
+  });
+});

package/src/lib/actions/action-service.ts

@@ -0,0 +1,87 @@
+import { Service, inject } from '@angular/core';
+
+import {
+  actionType,
+  getAction,
+  type ActionContext,
+  type ActionRequest,
+  type ActionResult,
+} from './action-registry';
+import type { ResourceAction } from '../core/models/schema.model';
+import { ConfigService } from '../core/services/config.service';
+import { ErrorMapperService } from '../core/services/error-mapper.service';
+
+/**
+ * Ejecuta una acción declarada en el schema (R3.9 · `refactormotor.md`).
+ *
+ * Sustituye el dispatch por tipo que hoy vive en `list-view` y en las
+ * copias de `detail-view` y `post-create-modal` (R3.11). El camino siempre
+ * es el mismo:
+ *
+ *   1. resolver el descriptor (si no existe, **rompe** — nada de «disponible
+ *      próximamente», que hoy oculta esquemas mal declarados);
+ *   2. pedir confirmación si el descriptor la exige;
+ *   3. montar el `ActionContext` (petición + `vars` de interpolación);
+ *   4. ejecutar y, si el descriptor lanza, notificar el error y devolver
+ *      `{ ok: false }` para que la vista no trate el fallo como éxito.
+ */
+@Service()
+export class ActionService {
+  private readonly config = inject(ConfigService);
+  private readonly errores = inject(ErrorMapperService);
+
+  async run(action: ResourceAction, request: ActionRequest): Promise<ActionResult> {
+    const type = actionType(action);
+    const descriptor = getAction(type);
+    if (!descriptor) {
+      throw new Error(
+        `[actions] «${action.label}» no tiene descriptor registrado (type "${type}").`,
+      );
+    }
+
+    if (descriptor.confirm) {
+      const aceptado = await request.toast.confirm({
+        title: action.label,
+        message: confirmMessage(action),
+        confirmLabel: 'Confirmar',
+        cancelLabel: 'Cancelar',
+      });
+      if (!aceptado) {
+        return { ok: false };
+      }
+    }
+
+    // `copy-share` (R8.7) resuelve su mensaje contra la config global
+    // (`share_message_template`). Si el load del bootstrap no llegó (arranque
+    // sin sesión o red lenta), lo pedimos ahora —con la sesión ya iniciada—
+    // ANTES de congelar `vars`: si no, el mensaje copiado degradaría a
+    // «sólo la URL» hasta el próximo F5.
+    if (descriptor.type === 'copy-share') {
+      await this.config.ensureLoaded();
+    }
+
+    const ctx: ActionContext = { ...request, vars: this.vars(request.record) };
+    try {
+      return await descriptor.run(ctx, action);
+    } catch (err) {
+      request.toast.error(this.errores.messageOf(err));
+      return { ok: false };
+    }
+  }
+
+  /**
+   * Config global + registro. Sin registro (`header`, `bulk`) el contexto de
+   * interpolación queda vacío: el descriptor no tiene nada que interpolar.
+   *
+   * Público porque `detail-view` sólo **presenta** una acción (pinta
+   * `<app-copy-share>`) en vez de ejecutarla, y aun así necesita el mismo
+   * contexto: R3.11 acabó con la tercera copia de esta lógica.
+   */
+  vars(record: Record<string, unknown> | null): Record<string, unknown> {
+    return record ? this.config.buildInterpolationContext(record) : {};
+  }
+}
+
+function confirmMessage(action: ResourceAction): string {
+  return 'confirmMessage' in action && action.confirmMessage ? action.confirmMessage : action.label;
+}

package/src/lib/actions/descriptors.spec.ts

@@ -0,0 +1,155 @@
+import { afterEach, beforeEach, describe, expect, it, vi, type MockInstance } from 'vitest';
+import { of } from 'rxjs';
+
+import { getAction, type ActionContext } from './action-registry';
+import { resolveShare } from './descriptors';
+import type { CopyShareAction, NavigateAction, TriggerAction } from '../core/models/schema.model';
+import type { ApiService } from '../core/services/api.service';
+import type { NotificationService } from '../core/services/notification.service';
+import type { Router } from '@angular/router';
+
+const VARS = { public_base_url: 'https://demo', ref: 'p1', customer_name: 'Ana' };
+
+const COMPARTIR: CopyShareAction = {
+  id: 'share',
+  label: 'Compartir',
+  type: 'copy-share',
+  urlTemplate: '{public_base_url}/p/{ref}',
+  shareTextTemplate: 'Hola {customer_name}, tu pedido {ref}',
+};
+
+function contexto(): ActionContext {
+  return {
+    record: { ref: 'p1' },
+    resource: 'orders',
+    api: { request: vi.fn().mockReturnValue(of({ ok: true })) } as unknown as ApiService,
+    router: { navigateByUrl: vi.fn().mockResolvedValue(true) } as unknown as Router,
+    toast: {
+      success: vi.fn(),
+      error: vi.fn(),
+      info: vi.fn(),
+      confirm: vi.fn(),
+      dismiss: vi.fn(),
+    } as unknown as NotificationService,
+    user: null,
+    keyField: 'ref',
+    vars: VARS,
+  };
+}
+
+/** El `run` de un tipo registrado; lanza si no existe (estado incoherente). */
+function ejecutar(type: string, action: CopyShareAction | NavigateAction | TriggerAction) {
+  const descriptor = getAction(type);
+  if (!descriptor) throw new Error(`sin descriptor «${type}»`);
+  return descriptor.run;
+}
+
+describe('resolveShare', () => {
+  it('interpola enlace y mensaje con el contexto del registro', () => {
+    expect(resolveShare(COMPARTIR, VARS)).toEqual({
+      url: 'https://demo/p/p1',
+      shareText: 'Hola Ana, tu pedido p1',
+    });
+  });
+
+  it('sin shareTextTemplate cae a share_message_template (config global)', () => {
+    const action: CopyShareAction = { ...COMPARTIR, shareTextTemplate: undefined };
+    expect(resolveShare(action, { ...VARS, share_message_template: 'Hola {ref}' })).toEqual({
+      url: 'https://demo/p/p1',
+      shareText: 'Hola p1',
+    });
+  });
+
+  it('sin plantilla ninguna el mensaje queda vacío', () => {
+    const action: CopyShareAction = { ...COMPARTIR, shareTextTemplate: undefined };
+    expect(resolveShare(action, VARS).shareText).toBe('');
+  });
+});
+
+describe('descriptores de acción', () => {
+  const escritor = vi.fn().mockResolvedValue(undefined);
+  let abrir: MockInstance;
+
+  beforeEach(() => {
+    escritor.mockClear();
+    Object.defineProperty(window.navigator, 'clipboard', {
+      value: { writeText: escritor },
+      configurable: true,
+    });
+    abrir = vi.spyOn(window, 'open').mockReturnValue(null);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it('copy-share copia el mensaje completo y lo anuncia', async () => {
+    const ctx = contexto();
+    const resultado = await ejecutar('copy-share', COMPARTIR)(ctx, COMPARTIR);
+
+    expect(escritor).toHaveBeenCalledWith('Hola Ana, tu pedido p1 https://demo/p/p1');
+    expect(ctx.toast.success).toHaveBeenCalledWith('Mensaje copiado al portapapeles.');
+    expect(resultado).toEqual({ ok: true });
+  });
+
+  it('navigate abre una URL absoluta en otra pestaña', async () => {
+    const action: NavigateAction = {
+      id: 'ver',
+      label: 'Ver público',
+      urlTemplate: '{public_base_url}/p/{ref}',
+    };
+    const ctx = contexto();
+
+    await ejecutar('navigate', action)(ctx, action);
+
+    expect(abrir).toHaveBeenCalledWith('https://demo/p/p1', '_blank', 'noopener');
+    expect(ctx.router.navigateByUrl).not.toHaveBeenCalled();
+  });
+
+  it('navigate entrega una ruta interna al router', async () => {
+    const action: NavigateAction = { id: 'editar', label: 'Editar', urlTemplate: '/orders/p1' };
+    const ctx = contexto();
+
+    await ejecutar('navigate', action)(ctx, action);
+
+    expect(ctx.router.navigateByUrl).toHaveBeenCalledWith('/orders/p1');
+    expect(abrir).not.toHaveBeenCalled();
+  });
+
+  it('trigger arma la ruta lógica de la acción declarada y pide recarga', async () => {
+    const action: TriggerAction = {
+      id: 'markDelivered',
+      label: 'Marcar entregado',
+      type: 'trigger',
+    };
+    const ctx = contexto();
+
+    const resultado = await ejecutar('trigger', action)(ctx, action);
+
+    expect(ctx.api.request).toHaveBeenCalledWith('POST', '/admin/orders/p1/actions/markDelivered');
+    expect(resultado).toEqual({ ok: true, reload: true });
+  });
+
+  it('trigger usa `name` cuando en el back se llama distinto que el `id`', async () => {
+    const action: TriggerAction = {
+      id: 'reenviar',
+      label: 'Reenviar pin',
+      type: 'trigger',
+      name: 'resendPin',
+    };
+    const ctx = contexto();
+
+    await ejecutar('trigger', action)(ctx, action);
+
+    expect(ctx.api.request).toHaveBeenCalledWith('POST', '/admin/orders/p1/actions/resendPin');
+  });
+
+  it('sin clave de registro no dispara nada y lo dice (fail-loud)', async () => {
+    const action: TriggerAction = { id: 'markDelivered', label: 'Marcar', type: 'trigger' };
+    const ctx = contexto();
+    ctx.record = null;
+
+    await expect(ejecutar('trigger', action)(ctx, action)).rejects.toThrow('necesita la clave ref');
+    expect(ctx.api.request).not.toHaveBeenCalled();
+  });
+});