@carlonicora/nextjs-jsonapi 5.2.0 → 5.4.0

package/src/features/email-automation/data/EmailAutomationService.ts

@@ -0,0 +1,106 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules, NextRef, PreviousRef } from "../../../core";
+import { EmailAutomationEnrollmentInterface } from "./EmailAutomationEnrollmentInterface";
+import { EmailAutomationInput, EmailAutomationInterface } from "./EmailAutomationInterface";
+import { EmailAutomationTriggerInterface } from "./EmailAutomationTriggerInterface";
+
+export class EmailAutomationService extends AbstractService {
+  static async findMany(params: { next?: NextRef; previous?: PreviousRef } = {}): Promise<EmailAutomationInterface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.EmailAutomation });
+
+    if (Modules.EmailAutomation.inclusions?.lists?.fields)
+      endpoint.limitToFields(Modules.EmailAutomation.inclusions.lists.fields);
+    if (Modules.EmailAutomation.inclusions?.lists?.types)
+      endpoint.limitToType(Modules.EmailAutomation.inclusions.lists.types);
+
+    return this.callApi<EmailAutomationInterface[]>({
+      type: Modules.EmailAutomation,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+      previous: params.previous,
+    });
+  }
+
+  static async findOne(params: { id: string }): Promise<EmailAutomationInterface> {
+    return this.callApi<EmailAutomationInterface>({
+      type: Modules.EmailAutomation,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomation, id: params.id }).generate(),
+    });
+  }
+
+  static async create(params: EmailAutomationInput): Promise<EmailAutomationInterface> {
+    return this.callApi<EmailAutomationInterface>({
+      type: Modules.EmailAutomation,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomation }).generate(),
+      input: params,
+    });
+  }
+
+  static async update(params: EmailAutomationInput): Promise<EmailAutomationInterface> {
+    return this.callApi<EmailAutomationInterface>({
+      type: Modules.EmailAutomation,
+      method: HttpMethod.PATCH,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomation, id: params.id }).generate(),
+      input: params,
+    });
+  }
+
+  static async delete(params: { id: string }): Promise<void> {
+    await this.callApi({
+      type: Modules.EmailAutomation,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomation, id: params.id }).generate(),
+    });
+  }
+
+  /**
+   * GET email-automations/triggers: the triggers the app declared to the API.
+   */
+  static async findTriggers(): Promise<EmailAutomationTriggerInterface[]> {
+    return this.callApi<EmailAutomationTriggerInterface[]>({
+      type: Modules.EmailAutomationTrigger,
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomation, id: "triggers" }).generate(),
+    });
+  }
+
+  /**
+   * POST email-automations/:id/tidy: clears every manual step position. Replies 204.
+   */
+  static async tidy(params: { id: string }): Promise<void> {
+    await this.callApi({
+      type: Modules.EmailAutomation,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.EmailAutomation,
+        id: params.id,
+        childEndpoint: "tidy",
+      }).generate(),
+    });
+  }
+
+  static async findEnrollments(params: {
+    automationId: string;
+    status?: string;
+    next?: NextRef;
+    previous?: PreviousRef;
+  }): Promise<EmailAutomationEnrollmentInterface[]> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.EmailAutomation,
+      id: params.automationId,
+      childEndpoint: Modules.EmailAutomationEnrollment,
+    });
+
+    if (params.status) endpoint.addAdditionalParam("status", params.status);
+
+    return this.callApi<EmailAutomationEnrollmentInterface[]>({
+      type: Modules.EmailAutomationEnrollment,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+      previous: params.previous,
+    });
+  }
+}

package/src/features/email-automation/data/EmailAutomationStep.ts

@@ -0,0 +1,104 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { EmailAutomationInterface } from "./EmailAutomationInterface";
+import { EmailAutomationStepInput, EmailAutomationStepInterface } from "./EmailAutomationStepInterface";
+
+export class EmailAutomationStep extends AbstractApiData implements EmailAutomationStepInterface {
+  private _subject?: string;
+  private _body?: string;
+  private _delayHours?: number;
+  private _positionX?: number;
+  private _positionY?: number;
+  private _sentCount?: number;
+  private _automation?: EmailAutomationInterface;
+  private _next?: EmailAutomationStepInterface;
+
+  get subject(): string {
+    return this._subject ?? "";
+  }
+
+  get body(): string {
+    return this._body ?? "";
+  }
+
+  get delayHours(): number {
+    return this._delayHours ?? 0;
+  }
+
+  get positionX(): number | undefined {
+    return this._positionX;
+  }
+
+  get positionY(): number | undefined {
+    return this._positionY;
+  }
+
+  get sentCount(): number {
+    return this._sentCount ?? 0;
+  }
+
+  get automation(): EmailAutomationInterface | undefined {
+    return this._automation;
+  }
+
+  get next(): EmailAutomationStepInterface | undefined {
+    return this._next;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._subject = data.jsonApi.attributes.subject;
+    this._body = data.jsonApi.attributes.body;
+    this._delayHours = data.jsonApi.attributes.delayHours;
+    this._positionX = data.jsonApi.attributes.positionX ?? undefined;
+    this._positionY = data.jsonApi.attributes.positionY ?? undefined;
+    this._sentCount = data.jsonApi.attributes.sentCount;
+
+    this._automation = this._readIncluded(data, "automation", Modules.EmailAutomation) as EmailAutomationInterface;
+    this._next = this._readIncluded(data, "next", Modules.EmailAutomationStep) as EmailAutomationStepInterface;
+
+    return this;
+  }
+
+  createJsonApi(data: EmailAutomationStepInput) {
+    const response: any = {
+      data: {
+        type: Modules.EmailAutomationStep.name,
+        id: data.id,
+        attributes: {},
+        meta: {},
+        relationships: {},
+      },
+      included: [],
+    };
+
+    if (data.subject !== undefined) response.data.attributes.subject = data.subject;
+    if (data.body !== undefined) response.data.attributes.body = data.body;
+    if (data.delayHours !== undefined) response.data.attributes.delayHours = data.delayHours;
+    if (data.positionX !== undefined) response.data.attributes.positionX = data.positionX;
+    if (data.positionY !== undefined) response.data.attributes.positionY = data.positionY;
+
+    if (data.automationId) {
+      response.data.relationships.automation = {
+        data: {
+          type: Modules.EmailAutomation.name,
+          id: data.automationId,
+        },
+      };
+    }
+
+    return response;
+  }
+
+  /**
+   * Body of POST email-automation-steps/:stepId/next: the step the chain continues to.
+   */
+  createNextJsonApi(params: { nextStepId: string }) {
+    return {
+      data: {
+        type: Modules.EmailAutomationStep.name,
+        id: params.nextStepId,
+      },
+    };
+  }
+}

package/src/features/email-automation/data/EmailAutomationStepInterface.ts

@@ -0,0 +1,23 @@
+import { ApiDataInterface } from "../../../core";
+import { EmailAutomationInterface } from "./EmailAutomationInterface";
+
+export type EmailAutomationStepInput = {
+  id: string;
+  automationId: string;
+  subject: string;
+  body: string;
+  delayHours?: number;
+  positionX?: number;
+  positionY?: number;
+};
+
+export interface EmailAutomationStepInterface extends ApiDataInterface {
+  get subject(): string;
+  get body(): string;
+  get delayHours(): number;
+  get positionX(): number | undefined;
+  get positionY(): number | undefined;
+  get sentCount(): number;
+  get automation(): EmailAutomationInterface | undefined;
+  get next(): EmailAutomationStepInterface | undefined;
+}

package/src/features/email-automation/data/EmailAutomationStepService.ts

@@ -0,0 +1,80 @@
+import { AbstractService, EndpointCreator, HttpMethod, Modules } from "../../../core";
+import { EmailAutomationStep } from "./EmailAutomationStep";
+import { EmailAutomationStepInput, EmailAutomationStepInterface } from "./EmailAutomationStepInterface";
+
+export class EmailAutomationStepService extends AbstractService {
+  static async findByAutomation(params: { automationId: string }): Promise<EmailAutomationStepInterface[]> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.EmailAutomation,
+      id: params.automationId,
+      childEndpoint: Modules.EmailAutomationStep,
+    });
+
+    endpoint.addAdditionalParam("fetchAll", "true");
+
+    return this.callApi<EmailAutomationStepInterface[]>({
+      type: Modules.EmailAutomationStep,
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+    });
+  }
+
+  static async create(params: EmailAutomationStepInput): Promise<EmailAutomationStepInterface> {
+    return this.callApi<EmailAutomationStepInterface>({
+      type: Modules.EmailAutomationStep,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomationStep }).generate(),
+      input: params,
+    });
+  }
+
+  static async update(params: EmailAutomationStepInput): Promise<EmailAutomationStepInterface> {
+    return this.callApi<EmailAutomationStepInterface>({
+      type: Modules.EmailAutomationStep,
+      method: HttpMethod.PATCH,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomationStep, id: params.id }).generate(),
+      input: params,
+    });
+  }
+
+  static async delete(params: { id: string }): Promise<void> {
+    await this.callApi({
+      type: Modules.EmailAutomationStep,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({ endpoint: Modules.EmailAutomationStep, id: params.id }).generate(),
+    });
+  }
+
+  /**
+   * POST email-automation-steps/:stepId/next: continues the chain from stepId to nextStepId.
+   */
+  static async setNext(params: { stepId: string; nextStepId: string }): Promise<EmailAutomationStepInterface> {
+    const step = new EmailAutomationStep();
+    return this.callApi<EmailAutomationStepInterface>({
+      type: Modules.EmailAutomationStep,
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.EmailAutomationStep,
+        id: params.stepId,
+        childEndpoint: "next",
+      }).generate(),
+      input: step.createNextJsonApi({ nextStepId: params.nextStepId }),
+      overridesJsonApiCreation: true,
+    });
+  }
+
+  /**
+   * DELETE email-automation-steps/:stepId/next: the step becomes the end of the chain.
+   */
+  static async clearNext(params: { stepId: string }): Promise<void> {
+    await this.callApi({
+      type: Modules.EmailAutomationStep,
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({
+        endpoint: Modules.EmailAutomationStep,
+        id: params.stepId,
+        childEndpoint: "next",
+      }).generate(),
+    });
+  }
+}

package/src/features/email-automation/data/EmailAutomationTrigger.ts

@@ -0,0 +1,28 @@
+import { AbstractApiData, JsonApiHydratedDataInterface } from "../../../core";
+import { EmailAutomationTriggerInterface } from "./EmailAutomationTriggerInterface";
+
+export class EmailAutomationTrigger extends AbstractApiData implements EmailAutomationTriggerInterface {
+  private _key?: string;
+  private _label?: string;
+
+  get key(): string {
+    return this._key ?? "";
+  }
+
+  get label(): string {
+    return this._label ?? "";
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._key = data.jsonApi.attributes.key;
+    this._label = data.jsonApi.attributes.label;
+
+    return this;
+  }
+
+  createJsonApi(_data?: any): any {
+    throw new Error("EmailAutomationTrigger is declared by the API and is read-only");
+  }
+}

package/src/features/email-automation/data/EmailAutomationTriggerInterface.ts

@@ -0,0 +1,6 @@
+import { ApiDataInterface } from "../../../core";
+
+export interface EmailAutomationTriggerInterface extends ApiDataInterface {
+  get key(): string;
+  get label(): string;
+}

package/src/features/email-automation/data/__tests__/email-automation-models.spec.ts

@@ -0,0 +1,103 @@
+import { beforeAll, describe, expect, it } from "vitest";
+import { ModuleRegistry } from "../../../../core/registry/ModuleRegistry";
+import { ModuleFactory, ModuleWithPermissions } from "../../../../permissions/types";
+import { EmailAutomationEnrollmentModule } from "../../EmailAutomationEnrollmentModule";
+import { EmailAutomationModule } from "../../EmailAutomationModule";
+import { EmailAutomationStepModule } from "../../EmailAutomationStepModule";
+import { EmailAutomationTriggerModule } from "../../EmailAutomationTriggerModule";
+import { EmailAutomation } from "../EmailAutomation";
+import { EMAIL_AUTOMATION_UNSUBSCRIBE_TYPE, EmailAutomationEnrollment } from "../EmailAutomationEnrollment";
+import { EmailAutomationStep } from "../EmailAutomationStep";
+
+// createJsonApi reads Modules.X.name (resolved lazily via ModuleRegistry), so
+// the modules must be registered before a model serialises — mirrors the
+// tokenusage-admin-models.spec setup convention in this package.
+const moduleFactory: ModuleFactory = (params) =>
+  ({
+    pageUrl: params.pageUrl,
+    name: params.name,
+    model: params.model,
+  }) as ModuleWithPermissions;
+
+beforeAll(() => {
+  ModuleRegistry.register("EmailAutomation", EmailAutomationModule(moduleFactory));
+  ModuleRegistry.register("EmailAutomationStep", EmailAutomationStepModule(moduleFactory));
+  ModuleRegistry.register("EmailAutomationEnrollment", EmailAutomationEnrollmentModule(moduleFactory));
+  ModuleRegistry.register("EmailAutomationTrigger", EmailAutomationTriggerModule(moduleFactory));
+});
+
+const hydrate = (attributes: Record<string, unknown>) =>
+  ({ jsonApi: { id: "x", type: "t", attributes }, included: [] }) as any;
+
+describe("email automation models", () => {
+  it("parses the enrollment datetimes into Date, not the wire string", () => {
+    const m = new EmailAutomationEnrollment().rehydrate(
+      hydrate({
+        email: "ada@example.com",
+        status: "active",
+        enrolledAt: "2026-10-21T08:00:00.000Z",
+        nextSendAt: "2026-10-22T08:00:00.000Z",
+        attempts: 0,
+      }),
+    );
+    expect(m.enrolledAt).toBeInstanceOf(Date);
+    expect(m.enrolledAt.toISOString()).toBe("2026-10-21T08:00:00.000Z");
+    expect(m.nextSendAt).toBeInstanceOf(Date);
+    expect(m.nextSendAt?.toISOString()).toBe("2026-10-22T08:00:00.000Z");
+    expect(m.finishedAt).toBeUndefined();
+  });
+
+  it("reads the enrollment computed fields from attributes", () => {
+    const m = new EmailAutomationEnrollment().rehydrate(
+      hydrate({
+        email: "ada@example.com",
+        status: "active",
+        enrolledAt: "2026-10-21T08:00:00.000Z",
+        currentStepSubject: "Welcome aboard",
+        sentCount: 2,
+      }),
+    );
+    expect(m.currentStepSubject).toBe("Welcome aboard");
+    expect(m.sentCount).toBe(2);
+  });
+
+  it("omits undefined automation attributes and includes isActive when given", () => {
+    const body = new EmailAutomation().createJsonApi({ id: "a1", name: "Onboarding", isActive: true });
+    expect(body.data.type).toBe("email-automations");
+    expect(body.data.id).toBe("a1");
+    expect(body.data.attributes).toEqual({ name: "Onboarding", isActive: true });
+    expect("trigger" in body.data.attributes).toBe(false);
+    expect("exitTrigger" in body.data.attributes).toBe(false);
+    expect("replyTo" in body.data.attributes).toBe(false);
+  });
+
+  it("includes isActive false when given", () => {
+    const body = new EmailAutomation().createJsonApi({ id: "a1", name: "Onboarding", isActive: false });
+    expect(body.data.attributes.isActive).toBe(false);
+  });
+
+  it("writes the step's automation relationship", () => {
+    const body = new EmailAutomationStep().createJsonApi({
+      id: "s1",
+      automationId: "a1",
+      subject: "Hello",
+      body: "Hi {{name}}",
+      delayHours: 24,
+    });
+    expect(body.data.type).toBe("email-automation-steps");
+    expect(body.data.attributes).toEqual({ subject: "Hello", body: "Hi {{name}}", delayHours: 24 });
+    expect(body.data.relationships.automation).toEqual({ data: { type: "email-automations", id: "a1" } });
+  });
+
+  it("builds the next-step body", () => {
+    expect(new EmailAutomationStep().createNextJsonApi({ nextStepId: "s2" })).toEqual({
+      data: { type: "email-automation-steps", id: "s2" },
+    });
+  });
+
+  it("builds the unsubscribe body", () => {
+    expect(new EmailAutomationEnrollment().createUnsubscribeJsonApi({ scope: "all" })).toEqual({
+      data: { type: EMAIL_AUTOMATION_UNSUBSCRIBE_TYPE, attributes: { scope: "all" } },
+    });
+  });
+});

package/src/features/email-automation/data/email-automation-enrollment.fields.ts

@@ -0,0 +1,8 @@
+export enum EmailAutomationEnrollmentFields {
+  email = "email",
+  name = "name",
+  status = "status",
+  currentStep = "currentStep",
+  nextSendAt = "nextSendAt",
+  sentCount = "sentCount",
+}

package/src/features/email-automation/data/email-automation.fields.ts

@@ -0,0 +1,9 @@
+export enum EmailAutomationFields {
+  name = "name",
+  trigger = "trigger",
+  status = "status",
+  steps = "steps",
+  active = "active",
+  completed = "completed",
+  unsubscribed = "unsubscribed",
+}

package/src/features/email-automation/data/index.ts

@@ -0,0 +1,13 @@
+export * from "./EmailAutomationInterface";
+export * from "./EmailAutomation";
+export * from "./EmailAutomationService";
+export * from "./EmailAutomationStepInterface";
+export * from "./EmailAutomationStep";
+export * from "./EmailAutomationStepService";
+export * from "./EmailAutomationEnrollmentInterface";
+export * from "./EmailAutomationEnrollment";
+export * from "./EmailAutomationEnrollmentService";
+export * from "./EmailAutomationTriggerInterface";
+export * from "./EmailAutomationTrigger";
+export * from "./email-automation.fields";
+export * from "./email-automation-enrollment.fields";

package/src/features/email-automation/hooks/index.ts

@@ -0,0 +1,2 @@
+export * from "./useEmailAutomationTableStructure";
+export * from "./useEmailAutomationEnrollmentTableStructure";

package/src/features/email-automation/hooks/useEmailAutomationEnrollmentTableStructure.tsx

@@ -0,0 +1,126 @@
+"use client";
+
+import { ColumnDef } from "@tanstack/react-table";
+import { useLocale, useTranslations } from "next-intl";
+import { useMemo } from "react";
+import { Badge } from "../../../shadcnui";
+import { registerTableGenerator, TableContent, UseTableStructureHook } from "../../../hooks";
+import { dateFormatLocale, formatDate } from "../../../utils/date-formatter";
+import { EmailAutomationEnrollmentFields } from "../data/email-automation-enrollment.fields";
+import { EmailAutomationEnrollmentInterface } from "../data/EmailAutomationEnrollmentInterface";
+
+const STATUS_VARIANTS: Record<string, "softGreen" | "softBlue" | "softGray" | "softRed"> = {
+  active: "softGreen",
+  completed: "softBlue",
+  unsubscribed: "softGray",
+  exited: "softGray",
+  failed: "softRed",
+};
+
+export const useEmailAutomationEnrollmentTableStructure: UseTableStructureHook<
+  EmailAutomationEnrollmentInterface,
+  EmailAutomationEnrollmentFields
+> = (params) => {
+  const t = useTranslations();
+  const locale = dateFormatLocale(useLocale());
+
+  const tableData = useMemo(() => {
+    return params.data.map((enrollment: EmailAutomationEnrollmentInterface) => {
+      const entry: TableContent<EmailAutomationEnrollmentInterface> = { jsonApiData: enrollment };
+      params.fields.forEach((field) => {
+        entry[field] = (enrollment as any)[field as keyof EmailAutomationEnrollmentInterface];
+      });
+      return entry;
+    });
+  }, [params.data, params.fields]);
+
+  const empty = <span className="text-muted-foreground text-xs">—</span>;
+
+  const fieldColumnMap: Partial<Record<EmailAutomationEnrollmentFields, () => any>> = {
+    [EmailAutomationEnrollmentFields.email]: () => ({
+      id: "email",
+      accessorKey: "email",
+      header: t("emailAutomations.recipients.columns.email"),
+      cell: ({ row }: { row: TableContent<EmailAutomationEnrollmentInterface> }) => {
+        const enrollment: EmailAutomationEnrollmentInterface = row.original.jsonApiData;
+        return <span className="text-sm">{enrollment.email}</span>;
+      },
+      enableSorting: false,
+      enableHiding: false,
+    }),
+    [EmailAutomationEnrollmentFields.name]: () => ({
+      id: "name",
+      accessorKey: "name",
+      header: t("emailAutomations.recipients.columns.name"),
+      cell: ({ row }: { row: TableContent<EmailAutomationEnrollmentInterface> }) => {
+        const enrollment: EmailAutomationEnrollmentInterface = row.original.jsonApiData;
+        return enrollment.name ? <span className="text-sm">{enrollment.name}</span> : empty;
+      },
+      enableSorting: false,
+      enableHiding: false,
+    }),
+    [EmailAutomationEnrollmentFields.status]: () => ({
+      id: "status",
+      accessorKey: "status",
+      header: t("emailAutomations.recipients.columns.status"),
+      cell: ({ row }: { row: TableContent<EmailAutomationEnrollmentInterface> }) => {
+        const enrollment: EmailAutomationEnrollmentInterface = row.original.jsonApiData;
+        return (
+          <Badge
+            variant={STATUS_VARIANTS[enrollment.status] ?? "softGray"}
+            title={enrollment.status === "failed" ? enrollment.lastError : undefined}
+          >
+            {t(`emailAutomations.recipients.status.${enrollment.status}`)}
+          </Badge>
+        );
+      },
+      enableSorting: false,
+      enableHiding: false,
+    }),
+    [EmailAutomationEnrollmentFields.currentStep]: () => ({
+      id: "currentStep",
+      accessorKey: "currentStep",
+      header: t("emailAutomations.recipients.columns.currentStep"),
+      cell: ({ row }: { row: TableContent<EmailAutomationEnrollmentInterface> }) => {
+        const enrollment: EmailAutomationEnrollmentInterface = row.original.jsonApiData;
+        return enrollment.currentStepSubject ? <span className="text-sm">{enrollment.currentStepSubject}</span> : empty;
+      },
+      enableSorting: false,
+      enableHiding: false,
+    }),
+    [EmailAutomationEnrollmentFields.nextSendAt]: () => ({
+      id: "nextSendAt",
+      accessorKey: "nextSendAt",
+      header: t("emailAutomations.recipients.columns.nextSendAt"),
+      cell: ({ row }: { row: TableContent<EmailAutomationEnrollmentInterface> }) => {
+        const enrollment: EmailAutomationEnrollmentInterface = row.original.jsonApiData;
+        if (!enrollment.nextSendAt) return empty;
+        return <span className="text-xs tabular-nums">{formatDate(enrollment.nextSendAt, "dateTime", locale)}</span>;
+      },
+      enableSorting: false,
+      enableHiding: false,
+    }),
+    [EmailAutomationEnrollmentFields.sentCount]: () => ({
+      id: "sentCount",
+      accessorKey: "sentCount",
+      header: t("emailAutomations.recipients.columns.sentCount"),
+      cell: ({ row }: { row: TableContent<EmailAutomationEnrollmentInterface> }) => {
+        const enrollment: EmailAutomationEnrollmentInterface = row.original.jsonApiData;
+        // Typography role 15 (numeric): tabular-nums, end-aligned.
+        return <span className="block text-xs tabular-nums text-end">{enrollment.sentCount ?? 0}</span>;
+      },
+      enableSorting: false,
+      enableHiding: false,
+    }),
+  };
+
+  const columns = useMemo(() => {
+    return params.fields.map((field) => fieldColumnMap[field]?.()).filter((col) => col !== undefined) as ColumnDef<
+      TableContent<EmailAutomationEnrollmentInterface>
+    >[];
+  }, [params.fields, fieldColumnMap, t, locale]);
+
+  return useMemo(() => ({ data: tableData, columns: columns }), [tableData, columns]);
+};
+
+registerTableGenerator("email-automation-enrollments", useEmailAutomationEnrollmentTableStructure);