@antelopejs/dms-mailing 0.3.3 → 0.4.0

package/src/test/unit/send.test.ts

@@ -1,161 +0,0 @@
-import type { EmailParams, EmailResponse } from "@antelopejs/interface-email";
-import { expect } from "chai";
-import type { SendTemplateParams } from "@antelopejs/interface-dms-mailing";
-import {
-  aggregateResults,
-  deliverBatch,
-  type DeliveredMessage,
-  type DeliveryInput,
-  deliverEach,
-  type PreparedSend,
-  recordAll,
-  type SendRecordInput,
-} from "../../services/send";
-import { DEFAULT_CATEGORIES, type MailingSettingsValues } from "../../types";
-
-const TRANSPORT_FAILURE = "socket hang up";
-const INSERT_FAILURE = "insert rejected";
-const RECIPIENTS = ["first@test.local", "second@test.local"];
-
-const PREPARED: PreparedSend = {
-  content: { locales: {} },
-  locale: "en",
-  templateId: "template-1",
-  slug: "welcome",
-  tenantId: "tenant-1",
-};
-
-const SETTINGS: MailingSettingsValues = {
-  fallbackLocale: "en",
-  logRetentionDays: 90,
-  blockOnMissingVariables: false,
-  senderName: "Sender",
-  senderEmail: "sender@test.local",
-  replyTo: "",
-  webhookSecret: "secret",
-  categories: DEFAULT_CATEGORIES,
-};
-
-const PARAMS: SendTemplateParams = {
-  tenantId: PREPARED.tenantId,
-  to: RECIPIENTS,
-};
-
-const input = (recipients: string[]): DeliveryInput => ({
-  prepared: PREPARED,
-  settings: SETTINGS,
-  subject: "Hello",
-  html: "<p>Hello</p>",
-  recipients,
-});
-
-const accepted = (messageId: string): EmailResponse => ({
-  success: true,
-  status: "sent",
-  messageId,
-  provider: "test",
-});
-
-const delivered = (
-  to: string,
-  overrides: Partial<DeliveredMessage> = {},
-): DeliveredMessage => ({
-  to,
-  status: "sent",
-  outcome: { latencyMs: 1, providerMessageId: `m-${to}` },
-  ...overrides,
-});
-
-describe("[unit] services/send delivery", () => {
-  it("keeps the messages the provider accepted when a later send throws", async () => {
-    const seen: string[] = [];
-    const send = async (params: EmailParams): Promise<EmailResponse> => {
-      const to = params.to as string;
-      seen.push(to);
-      if (to === RECIPIENTS[1]) throw new Error(TRANSPORT_FAILURE);
-      return accepted("m-1");
-    };
-
-    const messages = await deliverEach(input(RECIPIENTS), send);
-
-    expect(seen).to.deep.equal(RECIPIENTS);
-    expect(messages.map((message) => message.status)).to.deep.equal([
-      "sent",
-      "failed",
-    ]);
-    expect(messages[0]?.outcome.providerMessageId).to.equal("m-1");
-    expect(messages[1]?.outcome.error).to.contain(TRANSPORT_FAILURE);
-  });
-
-  it("keeps the sends it could record when a later insert throws", async () => {
-    const save = async (
-      _tenantId: string,
-      record: SendRecordInput,
-    ): Promise<string> => {
-      if (record.to === RECIPIENTS[1]) throw new Error(INSERT_FAILURE);
-      return "send-1";
-    };
-
-    const results = await recordAll(
-      PREPARED,
-      PARAMS,
-      RECIPIENTS.map((to) => delivered(to)),
-      save,
-    );
-
-    expect(results).to.have.length(2);
-    expect(results[0]?.sendId).to.equal("send-1");
-    expect(results[1]?.status).to.equal("failed");
-    expect(results[1]?.error).to.contain(INSERT_FAILURE);
-  });
-
-  it("fails every recipient when the batch call itself throws", async () => {
-    const messages = await deliverBatch(input(RECIPIENTS), () =>
-      Promise.reject(new Error(TRANSPORT_FAILURE)),
-    );
-
-    expect(messages.map((message) => message.status)).to.deep.equal([
-      "failed",
-      "failed",
-    ]);
-    expect(messages[0]?.outcome.error).to.contain(TRANSPORT_FAILURE);
-  });
-});
-
-describe("[unit] services/send result aggregation", () => {
-  it("reports the whole call while keeping the single-recipient shape", () => {
-    const single = aggregateResults([
-      { sendId: "send-1", status: "sent", messageId: "m-1" },
-    ]);
-
-    expect(single.sendId).to.equal("send-1");
-    expect(single.status).to.equal("sent");
-    expect(single.messageId).to.equal("m-1");
-    expect(single.error).to.equal(undefined);
-    expect(single.results).to.have.length(1);
-  });
-
-  it("degrades to the worst recipient outcome and surfaces its error", () => {
-    const results = [
-      { sendId: "send-1", status: "sent" as const, messageId: "m-1" },
-      { sendId: "send-2", status: "failed" as const, error: "Mailbox full" },
-    ];
-
-    const aggregated = aggregateResults(results);
-
-    expect(aggregated.sendId).to.equal("send-1");
-    expect(aggregated.messageId).to.equal("m-1");
-    expect(aggregated.status).to.equal("failed");
-    expect(aggregated.error).to.equal("Mailbox full");
-    expect(aggregated.results).to.deep.equal(results);
-  });
-
-  it("prefers the least advanced status when nothing failed", () => {
-    const aggregated = aggregateResults([
-      { sendId: "send-1", status: "sent" },
-      { sendId: "send-2", status: "queued" },
-    ]);
-
-    expect(aggregated.status).to.equal("queued");
-  });
-});

package/src/test/unit/smoke.test.ts

@@ -1,8 +0,0 @@
-import { expect } from "chai";
-import { MODULE_ID } from "../../constants";
-
-describe("[unit] smoke", () => {
-  it("exposes the module id", () => {
-    expect(MODULE_ID).to.equal("mailing");
-  });
-});

package/src/test/unit/status.test.ts

@@ -1,14 +0,0 @@
-import { expect } from "chai";
-import { toSendStatus } from "../../services/status";
-
-describe("[unit] services/status", () => {
-  it("maps provider statuses onto send statuses", () => {
-    expect(toSendStatus("queued")).to.equal("queued");
-    expect(toSendStatus("sent")).to.equal("sent");
-    expect(toSendStatus("delivered")).to.equal("delivered");
-    expect(toSendStatus("rejected")).to.equal("bounced");
-    expect(toSendStatus("scheduled")).to.equal("queued");
-    expect(toSendStatus("failed")).to.equal("failed");
-    expect(toSendStatus("unknown")).to.equal("sent");
-  });
-});

package/src/test/unit/templates.test.ts

@@ -1,52 +0,0 @@
-import { expect } from "chai";
-import { blankContent, localesOf } from "../../services/templates";
-import type { LocaleContent, TemplateContent } from "../../types";
-
-const emptyLocale = (): LocaleContent => ({
-  subject: "",
-  preheader: "",
-  blocks: [],
-});
-
-describe("[unit] services/templates localesOf", () => {
-  it("lists the locale codes present in the content", () => {
-    const content: TemplateContent = {
-      locales: { en: emptyLocale(), fr: emptyLocale() },
-    };
-    expect(localesOf(content)).to.equal("en,fr");
-  });
-
-  it("answers an empty string for content without locales", () => {
-    const content: TemplateContent = { locales: {} };
-    expect(localesOf(content)).to.equal("");
-  });
-});
-
-describe("[unit] services/templates blankContent", () => {
-  it("carries only a footer with the unsubscribe and preferences labels", () => {
-    const content = blankContent("en");
-    const locale = content.locales.en as LocaleContent;
-    expect(Object.keys(content.locales)).to.deep.equal(["en"]);
-    expect(locale.blocks).to.have.lengthOf(1);
-    const [footer] = locale.blocks;
-    expect(footer?.type).to.equal("footer");
-    expect(footer).to.include({
-      unsubscribeLabel: "Unsubscribe",
-      preferencesLabel: "Preferences",
-    });
-  });
-
-  it("invents no subject, preheader or footer prose", () => {
-    const locale = blankContent("en").locales.en as LocaleContent;
-    expect(locale.subject).to.equal("");
-    expect(locale.preheader).to.equal("");
-    expect(locale.blocks[0]).to.include({ text: "" });
-  });
-
-  it("localises the labels and falls back to English", () => {
-    const french = blankContent("fr").locales.fr as LocaleContent;
-    expect(french.blocks[0]).to.include({ unsubscribeLabel: "Se désinscrire" });
-    const unknown = blankContent("de").locales.de as LocaleContent;
-    expect(unknown.blocks[0]).to.include({ unsubscribeLabel: "Unsubscribe" });
-  });
-});

package/src/test/unit/tenant-export.test.ts

@@ -1,88 +0,0 @@
-import { GetRegisteredHooks, Hook } from "@antelopejs/interface-dms/hooks";
-import { expect } from "chai";
-import { MODULE_ID } from "../../constants";
-import { registerTenantExport } from "../../hooks";
-import {
-  type ExportPageLoader,
-  jsonArrayChunks,
-} from "../../hooks/tenant-export";
-
-const PAGE_SIZE = 3;
-const EXTRA_ROW = 1;
-const ROW_COUNT = PAGE_SIZE * 2 + EXTRA_ROW;
-
-interface ExportedRow {
-  index: number;
-}
-
-const ROWS: ExportedRow[] = Array.from(
-  { length: ROW_COUNT },
-  (_row, index) => ({ index }),
-);
-
-function pagedLoader(offsets: number[]): ExportPageLoader<ExportedRow> {
-  return (offset, size) => {
-    offsets.push(offset);
-    return Promise.resolve(ROWS.slice(offset, offset + size));
-  };
-}
-
-async function collect(chunks: AsyncGenerator<string>): Promise<string> {
-  let text = "";
-  for await (const chunk of chunks) text += chunk;
-  return text;
-}
-
-describe("[unit] hooks/tenant-export", () => {
-  it("contributes to the tenant data export under the module id", () => {
-    registerTenantExport();
-    const moduleIds = GetRegisteredHooks(Hook.TENANT_DATA_EXPORT).map(
-      (hook) => hook.moduleId,
-    );
-    expect(moduleIds).to.include(MODULE_ID);
-  });
-
-  it("streams a collection as one JSON array read page by page", async () => {
-    const offsets: number[] = [];
-    const signal = new AbortController().signal;
-
-    const text = await collect(
-      jsonArrayChunks(pagedLoader(offsets), signal, PAGE_SIZE),
-    );
-
-    expect(JSON.parse(text)).to.deep.equal(ROWS);
-    expect(offsets).to.deep.equal([0, PAGE_SIZE, PAGE_SIZE * 2]);
-  });
-
-  it("streams an empty array when the collection has no row", async () => {
-    const signal = new AbortController().signal;
-
-    const text = await collect(
-      jsonArrayChunks(() => Promise.resolve([]), signal, PAGE_SIZE),
-    );
-
-    expect(JSON.parse(text)).to.deep.equal([]);
-  });
-
-  it("stops streaming as soon as the export is aborted", async () => {
-    const controller = new AbortController();
-    const offsets: number[] = [];
-    const chunks = jsonArrayChunks(
-      pagedLoader(offsets),
-      controller.signal,
-      PAGE_SIZE,
-    );
-    await chunks.next();
-    controller.abort();
-
-    let aborted = false;
-    try {
-      await collect(chunks);
-    } catch {
-      aborted = true;
-    }
-
-    expect(aborted).to.equal(true);
-    expect(offsets).to.deep.equal([]);
-  });
-});

package/src/test/unit/webhook-secret.test.ts

@@ -1,51 +0,0 @@
-import { expect } from "chai";
-import { webhookSecretMatches } from "../../services/events";
-import { settingsSchema } from "../../validation/settings.schema";
-
-const VALID_SECRET = "a".repeat(48);
-
-const settings = (webhookSecret: string) => ({
-  fallbackLocale: "en",
-  logRetentionDays: 30,
-  blockOnMissingVariables: false,
-  senderName: "",
-  senderEmail: "",
-  replyTo: "",
-  webhookSecret,
-  categories: [],
-});
-
-describe("[unit] webhook secret", () => {
-  // The event endpoint is the module's only unauthenticated route: the secret
-  // is the whole gate, so an absent or blank one must close it, not open it.
-  it("refuses every request when no secret is stored", () => {
-    expect(webhookSecretMatches("", "")).to.equal(false);
-    expect(webhookSecretMatches(undefined, "")).to.equal(false);
-    expect(webhookSecretMatches(VALID_SECRET, "")).to.equal(false);
-    expect(webhookSecretMatches(VALID_SECRET, undefined)).to.equal(false);
-  });
-
-  it("refuses a missing or wrong header against a real secret", () => {
-    expect(webhookSecretMatches(undefined, VALID_SECRET)).to.equal(false);
-    expect(webhookSecretMatches("", VALID_SECRET)).to.equal(false);
-    expect(webhookSecretMatches("b".repeat(48), VALID_SECRET)).to.equal(false);
-    expect(webhookSecretMatches("a".repeat(47), VALID_SECRET)).to.equal(false);
-  });
-
-  it("accepts the exact secret", () => {
-    expect(webhookSecretMatches(VALID_SECRET, VALID_SECRET)).to.equal(true);
-  });
-});
-
-describe("[unit] settings validation", () => {
-  it("refuses to store a blank webhook secret", () => {
-    expect(() => settingsSchema.parse(settings(""))).to.throw();
-    expect(() => settingsSchema.parse(settings("short"))).to.throw();
-  });
-
-  it("accepts a secret long enough to be worth guessing", () => {
-    expect(settingsSchema.parse(settings(VALID_SECRET)).webhookSecret).to.equal(
-      VALID_SECRET,
-    );
-  });
-});