feat(notificaciones): ejecutar todos for servicios jobs

Add POST /notifications/run-all: runs the four notification jobs
(outstanding, payment confirmation, account status, trust confirmation)
sequentially with one shared set of flags from "Flags del envío".

Sequential rather than parallel — the jobs share the SES transport and
account status can self-throttle via useEmailLimit. A job that throws is
captured and the sweep continues, so one bad query cannot swallow the
other three envíos; the aggregate response carries per-job results plus
summed sent/skipped/failed and an errors count.

Audited as a single notification.run-all.run entry so one staff click is
one audit row. UI adds the button to the flags card, with a confirm when
debug is off, and a per-job summary in "Última respuesta".

apps/api/src/notifications/notification.types.ts

@@ -103,6 +103,44 @@ export type NotificationJobResponse =
       type: "TRUST_PAYMENT_CONFIRMATION";
     };
 
+/** The four jobs, in the order the "ejecutar todos" sweep runs them. */
+export type NotificationJobKind =
+  | "outstanding"
+  | "payment"
+  | "account"
+  | "trust";
+
+/**
+ * One entry of the run-all sweep. A job that throws does NOT abort the
+ * sweep — it is recorded with `ok: false` and the next job still runs, so a
+ * single bad query can't silently block the other three envíos.
+ */
+export interface NotificationRunAllJobResult {
+  kind: NotificationJobKind;
+  ok: boolean;
+  result?: NotificationJobResponse;
+  error?: string;
+}
+
+/**
+ * Aggregate response for `POST /notifications/run-all`. `sent/skipped/failed`
+ * are the sums across every job that completed; `jobs` keeps each job's own
+ * verbatim legacy response so the UI can still show per-job detail.
+ */
+export interface NotificationRunAllResponse {
+  request: "success";
+  notificationType: "runAllNotifications";
+  statusCode: 200;
+  debug: boolean;
+  sent: number;
+  skipped: number;
+  failed: number;
+  /** Jobs that threw — sweep continued past them. */
+  errors: number;
+  jobs: NotificationRunAllJobResult[];
+  type: "RUN_ALL";
+}
+
 /** Normalized record for a single send attempt, fed by all four jobs. */
 export interface SendAttempt {
   notificationType: EmailNotificationType;

apps/api/src/notifications/notifications.controller.ts

@@ -139,6 +139,35 @@ export class NotificationsController {
     return result;
   }
 
+  /**
+   * Run all four jobs sequentially with one set of flags. Audited as a
+   * single `notification.run-all.run` entry carrying the aggregate totals
+   * plus each job's outcome — the per-job endpoints are NOT re-audited, so
+   * the log has exactly one row per staff click.
+   */
+  @Post("run-all")
+  @RequireAbility("notification:send")
+  @HttpCode(200)
+  async runAll(
+    @Body() body: RunJobDto,
+    @Query() query: RunJobDto,
+    @Req() req: Request,
+  ) {
+    const flags = { ...query, ...body };
+    const result = await this.svc.runAll(flags);
+    void this.audit.log(actingId(req), "notification.run-all.run", {
+      debug: !!flags.debug,
+      ignoreDayRestriction: !!flags.ignoreDayRestriction,
+      useEmailLimit: !!flags.useEmailLimit,
+      sent: result.sent,
+      skipped: result.skipped,
+      failed: result.failed,
+      errors: result.errors,
+      jobs: result.jobs.map((j) => ({ kind: j.kind, ok: j.ok })),
+    });
+    return result;
+  }
+
   /* ----------------------------------------------------------- read views */
 
   @Get("log")

apps/api/src/notifications/notifications.service.ts

@@ -12,7 +12,10 @@ import { MailService } from "../mail/mail.service";
 import { PrismaService } from "../prisma/prisma.service";
 import {
   SendAttempt,
+  NotificationJobKind,
   NotificationJobResponse,
+  NotificationRunAllJobResult,
+  NotificationRunAllResponse,
   AttemptStatus,
 } from "./notification.types";
 import {
@@ -649,6 +652,66 @@ export class NotificationsService {
     return response;
   }
 
+  /**
+   * "Ejecutar todos" — run all four jobs back to back with one set of flags.
+   *
+   * Sequential on purpose: the jobs share the SES transport and Job 3 can
+   * self-throttle via `useEmailLimit`, so firing them in parallel would both
+   * defeat that pause and interleave `email_notification_log` writes for no
+   * gain. A job that throws is captured and the sweep continues — one bad
+   * query must not swallow the other three envíos.
+   */
+  async runAll(flags: {
+    debug?: boolean;
+    ignoreDayRestriction?: boolean;
+    useEmailLimit?: boolean;
+  }): Promise<NotificationRunAllResponse> {
+    const debug = !!flags.debug;
+    const steps: {
+      kind: NotificationJobKind;
+      run: () => Promise<NotificationJobResponse>;
+    }[] = [
+      { kind: "outstanding", run: () => this.runOutstandingPayments(flags) },
+      { kind: "payment", run: () => this.runPaymentConfirmation(flags) },
+      { kind: "account", run: () => this.runAccountStatus(flags) },
+      { kind: "trust", run: () => this.runTrustConfirmation(flags) },
+    ];
+
+    const jobs: NotificationRunAllJobResult[] = [];
+    let sent = 0;
+    let skipped = 0;
+    let failed = 0;
+    let errors = 0;
+
+    for (const step of steps) {
+      try {
+        const result = await step.run();
+        sent += result.sent;
+        skipped += result.skipped;
+        failed += result.failed;
+        jobs.push({ kind: step.kind, ok: true, result });
+      } catch (e) {
+        errors++;
+        const message = e instanceof Error ? e.message : String(e);
+        this.logger.error(`run-all: job ${step.kind} failed — ${message}`);
+        jobs.push({ kind: step.kind, ok: false, error: message });
+      }
+    }
+
+    return {
+      request: "success",
+      notificationType: "runAllNotifications",
+      statusCode: 200,
+      debug,
+      sent,
+      skipped,
+      failed,
+      errors,
+      jobs,
+      type: "RUN_ALL",
+    };
+  }
+
   /* ============================================================================
    *  Log browser — list / drill-down for the UI.
    * ========================================================================== */