@carlonicora/nextjs-jsonapi 6.8.0 → 6.9.0

package/src/features/email-blast/EmailBlastDeliveryModule.ts

@@ -0,0 +1,12 @@
+import { MailIcon } from "lucide-react";
+import { ModuleFactory } from "../../permissions";
+import { EmailBlastDelivery } from "./data/EmailBlastDelivery";
+
+export const EmailBlastDeliveryModule = (factory: ModuleFactory) =>
+  factory({
+    moduleId: "c47e9b1d-2a5f-4c83-9e60-1b7d4a3f8e25",
+    pageUrl: undefined,
+    name: "email-blast-deliveries",
+    model: EmailBlastDelivery,
+    icon: MailIcon,
+  });

package/src/features/email-blast/EmailBlastModule.ts

@@ -0,0 +1,28 @@
+import { SendIcon } from "lucide-react";
+import { createJsonApiInclusion } from "../../core";
+import { ModuleFactory } from "../../permissions";
+import { EmailBlast } from "./data/EmailBlast";
+
+export const EmailBlastModule = (factory: ModuleFactory) =>
+  factory({
+    moduleId: "8a1f4c2e-6b3d-4e9a-b7c5-2d0e9f1a6b48",
+    pageUrl: "/administration/email-blasts",
+    name: "email-blasts",
+    model: EmailBlast,
+    icon: SendIcon,
+    inclusions: {
+      lists: {
+        fields: [
+          createJsonApiInclusion("email-blasts", [
+            "subject",
+            "status",
+            "sentAt",
+            "recipientCount",
+            "sentCount",
+            "failedCount",
+            "unsubscribedCount",
+          ]),
+        ],
+      },
+    },
+  });

package/src/features/email-blast/components/containers/EmailBlastContainer.tsx

@@ -0,0 +1,145 @@
+"use client";
+
+import { LoaderCircleIcon, MailCheckIcon } from "lucide-react";
+import { useTranslations } from "next-intl";
+import { ReactNode, useCallback, useEffect, useState } from "react";
+import { CommonDeleter, RoundPageContainer } from "../../../../components";
+import { errorToast } from "../../../../components/errors/errorToast";
+import { DetailField } from "../../../../components/typography";
+import { SharedProvider } from "../../../../contexts/SharedContext";
+import { Modules } from "../../../../core";
+import { usePageUrlGenerator } from "../../../../hooks";
+import { useI18nLocale } from "../../../../i18n";
+import { BreadcrumbItemData } from "../../../../interfaces";
+import { Badge, Button } from "../../../../shadcnui";
+import { showToast } from "../../../../utils/toast";
+import { EmailBlastInterface, EmailBlastStatus } from "../../data/EmailBlastInterface";
+import { EmailBlastService } from "../../data/EmailBlastService";
+import { EmailBlastEditor } from "../forms/EmailBlastEditor";
+import { EmailBlastSendDialog } from "../forms/EmailBlastSendDialog";
+
+const STATUS_VARIANTS: Record<EmailBlastStatus, "softGray" | "softAmber" | "softGreen"> = {
+  draft: "softGray",
+  sending: "softAmber",
+  sent: "softGreen",
+};
+
+export type EmailBlastContainerProps = {
+  blastId: string;
+};
+
+function EmailBlastSendTestButton({ blast }: { blast: EmailBlastInterface }) {
+  const t = useTranslations();
+  const [isSending, setIsSending] = useState<boolean>(false);
+
+  const handleClick = async () => {
+    setIsSending(true);
+    try {
+      await EmailBlastService.sendTest({ id: blast.id });
+      showToast(t("emailBlasts.test.sent"));
+    } catch (error) {
+      errorToast({ title: t("common.errors.error"), error });
+    } finally {
+      setIsSending(false);
+    }
+  };
+
+  return (
+    <Button size="sm" variant="outline" type="button" onClick={handleClick} disabled={isSending}>
+      {isSending ? <LoaderCircleIcon className="animate-spin-slow" /> : <MailCheckIcon />}
+      {t("emailBlasts.test.button")}
+    </Button>
+  );
+}
+
+export function EmailBlastContainer({ blastId }: EmailBlastContainerProps) {
+  const t = useTranslations();
+  const locale = useI18nLocale();
+  const generateUrl = usePageUrlGenerator();
+  const [blast, setBlast] = useState<EmailBlastInterface | undefined>(undefined);
+
+  const reload = useCallback(async () => {
+    setBlast(await EmailBlastService.findOne({ id: blastId }));
+  }, [blastId]);
+
+  useEffect(() => {
+    void reload();
+  }, [reload]);
+
+  if (!blast) return null;
+
+  const listUrl = generateUrl({ page: Modules.EmailBlast });
+
+  const breadcrumbs: BreadcrumbItemData[] = [
+    { name: t("emailBlasts.admin.title"), href: listUrl },
+    { name: blast.subject },
+  ];
+
+  // Only a draft can be edited, test-sent, sent or deleted (the API refuses the rest).
+  const functions: ReactNode[] =
+    blast.status === "draft"
+      ? [
+          <EmailBlastEditor key="emailBlastEditor" blast={blast} onSuccess={reload} />,
+          <EmailBlastSendTestButton key="emailBlastSendTest" blast={blast} />,
+          <EmailBlastSendDialog key="emailBlastSendDialog" blast={blast} onSuccess={reload} />,
+          <CommonDeleter
+            key="emailBlastDeleter"
+            type="email-blasts"
+            deleteFunction={() => EmailBlastService.delete({ id: blast.id })}
+            redirectTo={listUrl}
+          />,
+        ]
+      : [];
+
+  // The page chrome (title + header functions) is published here rather than by
+  // AdministrationProvider: SharedProvider replaces its value for the subtree,
+  // so this one carries the administration title type plus the blast subject.
+  return (
+    <SharedProvider
+      value={{
+        breadcrumbs,
+        title: {
+          type: t("emailBlasts.admin.title"),
+          element: blast.subject,
+          functions,
+        },
+      }}
+    >
+      <RoundPageContainer module={Modules.EmailBlast} id={blast.id} fullWidth forceHeader>
+        <div className="flex w-full flex-col gap-y-6 p-4">
+          <div>
+            <Badge variant={STATUS_VARIANTS[blast.status]}>{t(`emailBlasts.list.status.${blast.status}`)}</Badge>
+          </div>
+          <div className="grid grid-cols-2 gap-4 md:grid-cols-4">
+            <DetailField
+              label={t("emailBlasts.detail.recipients")}
+              value={<span className="tabular-nums">{blast.recipientCount ?? "—"}</span>}
+            />
+            <DetailField
+              label={t("emailBlasts.detail.sentTo")}
+              value={<span className="tabular-nums">{blast.sentCount}</span>}
+            />
+            <DetailField
+              label={t("emailBlasts.detail.failed")}
+              value={<span className="tabular-nums">{blast.failedCount}</span>}
+            />
+            <DetailField
+              label={t("emailBlasts.detail.unsubscribed")}
+              value={<span className="tabular-nums">{blast.unsubscribedCount}</span>}
+            />
+          </div>
+          <DetailField
+            label={t("emailBlasts.detail.sentAt")}
+            value={blast.sentAt ? blast.sentAt.toLocaleString(locale) : "—"}
+          />
+          <DetailField label={t("emailBlasts.list.columns.subject")} value={blast.subject} />
+          <DetailField label={t("emailBlasts.detail.replyTo")} value={blast.replyTo ?? "—"} />
+          <DetailField
+            label={t("emailBlasts.detail.body")}
+            value={<div className="whitespace-pre-wrap leading-relaxed">{blast.body}</div>}
+          />
+        </div>
+      </RoundPageContainer>
+    </SharedProvider>
+  );
+}

package/src/features/email-blast/components/containers/EmailBlastsListContainer.tsx

@@ -0,0 +1,36 @@
+"use client";
+
+import { useTranslations } from "next-intl";
+import { RoundPageContainer } from "../../../../components";
+import { SharedProvider } from "../../../../contexts/SharedContext";
+import { Modules } from "../../../../core";
+import { BreadcrumbItemData } from "../../../../interfaces";
+import { EmailBlastsList } from "../lists/EmailBlastsList";
+
+/**
+ * Page container for the administrative email-blast list.
+ *
+ * Client component by necessity: `module={Modules.EmailBlast}` is a
+ * registry entry carrying an icon component and methods, which a Server
+ * Component cannot pass across the boundary. Routes mount this container
+ * instead — the same shape as every other list page.
+ *
+ * No `forceHeader`: ContentListTable draws its own header row with the title
+ * and the create action, exactly as the company and user list pages do.
+ *
+ * Publishes its own breadcrumb, as CompanyProvider does for the companies list:
+ * the list root comes first and has no href because it is the current page.
+ */
+export function EmailBlastsListContainer() {
+  const t = useTranslations();
+
+  const breadcrumbs: BreadcrumbItemData[] = [{ name: t("emailBlasts.admin.title") }];
+
+  return (
+    <SharedProvider value={{ breadcrumbs, title: { type: t("emailBlasts.admin.title") } }}>
+      <RoundPageContainer module={Modules.EmailBlast} fullWidth>
+        <EmailBlastsList fullWidth />
+      </RoundPageContainer>
+    </SharedProvider>
+  );
+}

package/src/features/email-blast/components/forms/EmailBlastEditor.tsx

@@ -0,0 +1,132 @@
+"use client";
+
+import { zodResolver } from "@hookform/resolvers/zod";
+import { useTranslations } from "next-intl";
+import { ReactNode, useCallback, useMemo } from "react";
+import { useForm } from "react-hook-form";
+import { v4 } from "uuid";
+import { z } from "zod";
+import { EditorSheet, FormInput, FormTextarea } from "../../../../components";
+import { Modules } from "../../../../core";
+import { useI18nRouter } from "../../../../i18n";
+import { EmailBlastInput, EmailBlastInterface } from "../../data/EmailBlastInterface";
+import { EmailBlastService } from "../../data/EmailBlastService";
+
+/** The fixed variable set the blast renderer fills. */
+const TEMPLATE_VARIABLES = ["{{name}}", "{{email}}", "{{url}}", "{{unsubscribeAllUrl}}"];
+
+export type EmailBlastEditorProps = {
+  blast?: EmailBlastInterface;
+  propagateChanges?: (blast: EmailBlastInterface) => void;
+  onSuccess?: () => void | Promise<void>;
+  trigger?: ReactNode;
+  forceShow?: boolean;
+  onClose?: () => void;
+  dialogOpen?: boolean;
+  onDialogOpenChange?: (open: boolean) => void;
+};
+
+function EmailBlastEditorInternal({
+  blast,
+  propagateChanges,
+  onSuccess,
+  trigger,
+  forceShow,
+  onClose,
+  dialogOpen,
+  onDialogOpenChange,
+}: EmailBlastEditorProps) {
+  const t = useTranslations();
+  const router = useI18nRouter();
+  const isEdit = !!blast;
+
+  const formSchema = useMemo(
+    () =>
+      z.object({
+        id: z.uuidv4(),
+        subject: z.string().min(1, { message: t("emailBlasts.editor.fields.subject.error") }),
+        body: z.string().min(1, { message: t("emailBlasts.editor.fields.body.error") }),
+        replyTo: z.string().refine((value) => value === "" || z.email().safeParse(value).success, {
+          message: t("emailBlasts.editor.fields.replyTo.error"),
+        }),
+      }),
+    [t],
+  );
+
+  const getDefaultValues = useCallback(
+    () => ({
+      id: blast?.id ?? v4(),
+      subject: blast?.subject ?? "",
+      body: blast?.body ?? "",
+      replyTo: blast?.replyTo ?? "",
+    }),
+    [blast],
+  );
+
+  const form = useForm<z.infer<typeof formSchema>>({
+    resolver: zodResolver(formSchema),
+    defaultValues: getDefaultValues(),
+  });
+
+  return (
+    <EditorSheet
+      form={form}
+      entityType={t("emailBlasts.editor.title")}
+      entityName={blast?.subject}
+      title={isEdit ? t("emailBlasts.editor.editTitle") : t("emailBlasts.editor.title")}
+      isEdit={isEdit}
+      module={Modules.EmailBlast}
+      size="lg"
+      propagateChanges={propagateChanges}
+      onSuccess={onSuccess}
+      onNavigate={(url) => router.push(url)}
+      onSubmit={async (values) => {
+        const payload: EmailBlastInput = {
+          id: values.id,
+          subject: values.subject,
+          body: values.body,
+          replyTo: values.replyTo || undefined,
+        };
+        return isEdit ? await EmailBlastService.update(payload) : await EmailBlastService.create(payload);
+      }}
+      onReset={getDefaultValues}
+      trigger={trigger}
+      forceShow={forceShow}
+      onClose={onClose}
+      dialogOpen={dialogOpen}
+      onDialogOpenChange={onDialogOpenChange}
+    >
+      <div className="flex w-full flex-col gap-y-4">
+        <FormInput form={form} id="subject" name={t("emailBlasts.editor.fields.subject.label")} isRequired />
+        <FormInput form={form} id="replyTo" name={t("emailBlasts.editor.fields.replyTo.label")} />
+        {/* FormTextarea has no `rows` prop; min-h-72 is the height of ~14 rows. */}
+        <FormTextarea
+          form={form}
+          id="body"
+          name={t("emailBlasts.editor.fields.body.label")}
+          className="min-h-72"
+          isRequired
+          description={
+            <>
+              <span className="block">
+                {t("emailBlasts.editor.variablesHint")}{" "}
+                {TEMPLATE_VARIABLES.map((variable) => (
+                  <span key={variable} className="me-2 text-foreground">
+                    {variable}
+                  </span>
+                ))}
+              </span>
+              <span className="mt-1 block">{t("emailBlasts.editor.unsubscribeHint")}</span>
+            </>
+          }
+        />
+      </div>
+    </EditorSheet>
+  );
+}
+
+export function EmailBlastEditor(props: EmailBlastEditorProps) {
+  return <EmailBlastEditorInternal {...props} />;
+}
+
+export default EmailBlastEditor;

package/src/features/email-blast/components/forms/EmailBlastSendDialog.tsx

@@ -0,0 +1,104 @@
+"use client";
+
+import { LoaderCircleIcon, SendIcon } from "lucide-react";
+import { useTranslations } from "next-intl";
+import { useEffect, useState } from "react";
+import { errorToast } from "../../../../components/errors/errorToast";
+import {
+  AlertDialog,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  AlertDialogTrigger,
+} from "../../../../shadcnui/ui/alert-dialog";
+import { Button } from "../../../../shadcnui/ui/button";
+import { EmailBlastInterface } from "../../data/EmailBlastInterface";
+import { EmailBlastService } from "../../data/EmailBlastService";
+
+export type EmailBlastSendDialogProps = {
+  blast: EmailBlastInterface;
+  onSuccess?: () => void | Promise<void>;
+};
+
+/**
+ * Header action on a draft blast: asks how many people it reaches now, then sends.
+ * Same AlertDialog shape as AccountDeletionAdminTrigger.
+ */
+export function EmailBlastSendDialog({ blast, onSuccess }: EmailBlastSendDialogProps) {
+  const t = useTranslations();
+  const [open, setOpen] = useState<boolean>(false);
+  const [count, setCount] = useState<number | undefined>(undefined);
+  const [isSending, setIsSending] = useState<boolean>(false);
+
+  // The count is read each time the dialog opens: consent and opt-outs change.
+  useEffect(() => {
+    if (!open) return;
+    let cancelled = false;
+    setCount(undefined);
+    EmailBlastService.findAudience({ id: blast.id })
+      .then((audience) => {
+        if (!cancelled) setCount(audience.recipientCount);
+      })
+      .catch((error) => {
+        if (!cancelled) errorToast({ title: t("common.errors.error"), error });
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [open, blast.id, t]);
+
+  const isLoading = count === undefined;
+  const canSend = !isLoading && count > 0 && !isSending;
+
+  const handleSend = async () => {
+    setIsSending(true);
+    try {
+      await EmailBlastService.send({ id: blast.id });
+      await onSuccess?.();
+      setOpen(false);
+    } catch (error) {
+      errorToast({ title: t("common.errors.error"), error });
+    } finally {
+      setIsSending(false);
+    }
+  };
+
+  return (
+    <AlertDialog open={open} onOpenChange={setOpen}>
+      <AlertDialogTrigger render={<Button size="sm" variant="default" />}>
+        <SendIcon />
+        {t("emailBlasts.send.button")}
+      </AlertDialogTrigger>
+      <AlertDialogContent className="flex max-h-[70vh] max-w-3xl flex-col overflow-y-auto">
+        <AlertDialogHeader>
+          <AlertDialogTitle>{t("emailBlasts.send.title")}</AlertDialogTitle>
+          <AlertDialogDescription>
+            {isLoading ? (
+              <LoaderCircleIcon className="animate-spin-slow h-5 w-5" />
+            ) : count === 0 ? (
+              t("emailBlasts.send.nobody")
+            ) : (
+              t("emailBlasts.send.confirm", { count })
+            )}
+          </AlertDialogDescription>
+        </AlertDialogHeader>
+        <div className="flex justify-end">
+          <Button className="me-2" variant="outline" type="button" onClick={() => setOpen(false)} disabled={isSending}>
+            {t("emailBlasts.send.cancel")}
+          </Button>
+          <Button type="button" variant="default" onClick={handleSend} disabled={!canSend}>
+            {isSending ? (
+              <>
+                {t("emailBlasts.send.action")}
+                <LoaderCircleIcon className="animate-spin-slow h-5 w-5" />
+              </>
+            ) : (
+              t("emailBlasts.send.action")
+            )}
+          </Button>
+        </div>
+      </AlertDialogContent>
+    </AlertDialog>
+  );
+}

package/src/features/email-blast/components/index.ts

@@ -0,0 +1,5 @@
+export * from "./containers/EmailBlastsListContainer";
+export * from "./containers/EmailBlastContainer";
+export * from "./lists/EmailBlastsList";
+export * from "./forms/EmailBlastEditor";
+export * from "./forms/EmailBlastSendDialog";

package/src/features/email-blast/components/lists/EmailBlastsList.tsx

@@ -0,0 +1,57 @@
+"use client";
+
+import { SendIcon } from "lucide-react";
+import { useTranslations } from "next-intl";
+import { ReactNode } from "react";
+import { ContentListTable } from "../../../../components";
+import { Modules } from "../../../../core";
+import { DataListRetriever, useDataListRetriever } from "../../../../hooks";
+import { EmptyState } from "../../../../shadcnui";
+import { EmailBlastFields } from "../../data/email-blast.fields";
+import { EmailBlastInterface } from "../../data/EmailBlastInterface";
+import { EmailBlastService } from "../../data/EmailBlastService";
+// Registers the "email-blasts" table generator. The blast components ship in the
+// shared ./components entry, which does not re-export feature hooks (HowToList pattern).
+import "../../hooks/useEmailBlastTableStructure";
+import EmailBlastEditor from "../forms/EmailBlastEditor";
+
+type EmailBlastsListProps = {
+  /**
+   * Pass this whenever the list is the page's own content inside a
+   * `RoundPageContainer fullWidth`. Without it ContentListTable wraps itself in
+   * `rounded-md border`, drawing a second bordered card inside the page's
+   * rounded shell.
+   */
+  fullWidth?: boolean;
+};
+
+export function EmailBlastsList({ fullWidth }: EmailBlastsListProps = {}) {
+  const t = useTranslations();
+
+  const data: DataListRetriever<EmailBlastInterface> = useDataListRetriever({
+    retriever: (params) => EmailBlastService.findMany(params),
+    retrieverParams: {},
+    module: Modules.EmailBlast,
+  });
+
+  const functions: ReactNode[] = [<EmailBlastEditor key="create-email-blast" />];
+
+  return (
+    <ContentListTable
+      data={data}
+      fields={[
+        EmailBlastFields.subject,
+        EmailBlastFields.status,
+        EmailBlastFields.sentAt,
+        EmailBlastFields.sent,
+        EmailBlastFields.failed,
+        EmailBlastFields.unsubscribed,
+      ]}
+      tableGeneratorType={Modules.EmailBlast}
+      functions={functions}
+      fullWidth={fullWidth}
+      title={t("emailBlasts.admin.title")}
+      emptyState={<EmptyState icon={SendIcon} title={t("emailBlasts.admin.empty")} />}
+    />
+  );
+}

package/src/features/email-blast/data/EmailBlast.ts

@@ -0,0 +1,89 @@
+import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "../../../core";
+import { EmailBlastInput, EmailBlastInterface, EmailBlastStatus } from "./EmailBlastInterface";
+
+export class EmailBlast extends AbstractApiData implements EmailBlastInterface {
+  private _subject?: string;
+  private _body?: string;
+  private _replyTo?: string;
+  private _status: EmailBlastStatus = "draft";
+  private _sentAt?: Date;
+  private _recipientCount?: number;
+  private _sentCount?: number;
+  private _failedCount?: number;
+  private _unsubscribedCount?: number;
+
+  get subject(): string {
+    return this._subject ?? "";
+  }
+
+  get body(): string {
+    return this._body ?? "";
+  }
+
+  get replyTo(): string | undefined {
+    return this._replyTo;
+  }
+
+  get status(): EmailBlastStatus {
+    return this._status;
+  }
+
+  get sentAt(): Date | undefined {
+    return this._sentAt;
+  }
+
+  get recipientCount(): number | undefined {
+    return this._recipientCount;
+  }
+
+  get sentCount(): number {
+    return this._sentCount ?? 0;
+  }
+
+  get failedCount(): number {
+    return this._failedCount ?? 0;
+  }
+
+  get unsubscribedCount(): number {
+    return this._unsubscribedCount ?? 0;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    const attributes = data.jsonApi.attributes;
+    this._subject = attributes.subject;
+    this._body = attributes.body;
+    this._replyTo = attributes.replyTo ?? undefined;
+    this._status = attributes.status ?? "draft";
+    this._sentAt = attributes.sentAt ? new Date(attributes.sentAt) : undefined;
+    this._recipientCount = attributes.recipientCount ?? undefined;
+    this._sentCount = attributes.sentCount;
+    this._failedCount = attributes.failedCount;
+    this._unsubscribedCount = attributes.unsubscribedCount;
+
+    return this;
+  }
+
+  /**
+   * Only the editable text travels: status, counters and sentAt are set by the API.
+   */
+  createJsonApi(data: EmailBlastInput) {
+    const response: any = {
+      data: {
+        type: Modules.EmailBlast.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.replyTo !== undefined) response.data.attributes.replyTo = data.replyTo;
+
+    return response;
+  }
+}

package/src/features/email-blast/data/EmailBlastAudience.ts

@@ -0,0 +1,22 @@
+import { AbstractApiData, JsonApiHydratedDataInterface } from "../../../core";
+import { EmailBlastAudienceInterface } from "./EmailBlastAudienceInterface";
+
+export class EmailBlastAudience extends AbstractApiData implements EmailBlastAudienceInterface {
+  private _recipientCount?: number;
+
+  get recipientCount(): number {
+    return this._recipientCount ?? 0;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._recipientCount = data.jsonApi.attributes.recipientCount;
+
+    return this;
+  }
+
+  createJsonApi(_data?: any): any {
+    throw new Error("EmailBlastAudience is computed by the API and is read-only");
+  }
+}

package/src/features/email-blast/data/EmailBlastAudienceInterface.ts

@@ -0,0 +1,5 @@
+import { ApiDataInterface } from "../../../core";
+
+export interface EmailBlastAudienceInterface extends ApiDataInterface {
+  get recipientCount(): number;
+}

package/src/features/email-blast/data/EmailBlastDelivery.ts

@@ -0,0 +1,36 @@
+import { AbstractApiData, JsonApiHydratedDataInterface } from "../../../core";
+import { EmailBlastDeliveryInterface, EmailBlastDeliveryStatus } from "./EmailBlastDeliveryInterface";
+
+/** JSON:API type of the POST email-blasts/unsubscribe/:token request body (not a module: nothing is stored). */
+export const EMAIL_BLAST_UNSUBSCRIBE_TYPE = "email-blast-unsubscribes";
+
+export class EmailBlastDelivery extends AbstractApiData implements EmailBlastDeliveryInterface {
+  private _status: EmailBlastDeliveryStatus = "pending";
+
+  get status(): EmailBlastDeliveryStatus {
+    return this._status;
+  }
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+
+    this._status = data.jsonApi.attributes.status ?? "pending";
+
+    return this;
+  }
+
+  createJsonApi(_data?: any): any {
+    throw new Error("EmailBlastDelivery is created by the API and cannot be created from the client");
+  }
+
+  /**
+   * Body of POST email-blasts/unsubscribe/:token.
+   */
+  createUnsubscribeJsonApi() {
+    return {
+      data: {
+        type: EMAIL_BLAST_UNSUBSCRIBE_TYPE,
+      },
+    };
+  }
+}