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

package/ng-package.json

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

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

@@ -1,52 +0,0 @@
-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

@@ -1,126 +0,0 @@
-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

@@ -1,215 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,155 +0,0 @@
-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();
-  });
-});