@antelopejs/dms-mailing 0.3.4 → 0.4.0

package/src/test/unit/automation.test.ts

@@ -1,130 +0,0 @@
-import { expect } from "chai";
-import { unregisterAutomationNodes } from "../../automation";
-import {
-  clearEmailEventSubscriptions,
-  type EmailEventPayload,
-  emailEventTrigger,
-  emitEmailEvent,
-} from "../../automation/email-event-trigger";
-import { sendTemplateAction } from "../../automation/send-template-action";
-
-const EVENT: EmailEventPayload = {
-  tenantId: "t",
-  sendId: "s",
-  templateSlug: "x",
-  type: "bounced",
-  recipientEmail: "a@b",
-};
-
-describe("[unit] automation nodes", () => {
-  afterEach(() => {
-    clearEmailEventSubscriptions();
-  });
-
-  it("describes the send-template action", () => {
-    expect(sendTemplateAction.id).to.equal("mailing.send-template");
-    expect(sendTemplateAction.inputSchema).to.deep.include({
-      required: ["tenantId", "slug", "to"],
-    });
-  });
-
-  // The automation module ships no loop node: a procedure cannot call this
-  // action once per contact, so the fan-out has to happen inside it. The port
-  // must therefore accept a list, which `sendTemplate` already handles.
-  it("accepts a list of recipients on the `to` port, not just one address", () => {
-    const properties = (
-      sendTemplateAction.inputSchema as {
-        properties: Record<string, { type?: unknown; items?: unknown }>;
-      }
-    ).properties;
-    const to = properties.to as { type?: unknown; items?: unknown };
-    expect(to.type).to.deep.equal(["string", "array"]);
-    expect(to.items).to.deep.equal({ type: "string" });
-  });
-
-  it("fans e-mail events out to active trigger subscriptions filtered by type", async () => {
-    const received: unknown[] = [];
-    const handle = await emailEventTrigger.activate(
-      { types: ["bounced"] },
-      (payload) => {
-        received.push(payload);
-      },
-    );
-    emitEmailEvent({
-      tenantId: "t",
-      sendId: "s",
-      templateSlug: "x",
-      type: "opened",
-      recipientEmail: "a@b",
-    });
-    emitEmailEvent({
-      tenantId: "t",
-      sendId: "s",
-      templateSlug: "x",
-      type: "bounced",
-      recipientEmail: "a@b",
-    });
-    await emailEventTrigger.deactivate(handle);
-    emitEmailEvent({
-      tenantId: "t",
-      sendId: "s",
-      templateSlug: "x",
-      type: "bounced",
-      recipientEmail: "a@b",
-    });
-    expect(received).to.have.length(1);
-  });
-
-  it("fans every event out to a subscription that filters no type", async () => {
-    const received: unknown[] = [];
-    const handle = await emailEventTrigger.activate({}, (payload) => {
-      received.push(payload);
-    });
-    emitEmailEvent({
-      tenantId: "t",
-      sendId: "s",
-      templateSlug: "x",
-      type: "opened",
-      recipientEmail: "a@b",
-    });
-    await emailEventTrigger.deactivate(handle);
-    expect(received).to.have.length(1);
-  });
-
-  it("keeps fanning out when a subscription throws", async () => {
-    const received: EmailEventPayload[] = [];
-    await emailEventTrigger.activate({}, () => {
-      throw new Error("subscriber exploded");
-    });
-    await emailEventTrigger.activate({}, (payload) => {
-      received.push(payload);
-    });
-
-    expect(() => emitEmailEvent(EVENT)).to.not.throw();
-    expect(received).to.deep.equal([EVENT]);
-  });
-
-  it("stops fanning out once the subscriptions are cleared", async () => {
-    const received: EmailEventPayload[] = [];
-    await emailEventTrigger.activate({}, (payload) => {
-      received.push(payload);
-    });
-
-    clearEmailEventSubscriptions();
-    emitEmailEvent(EVENT);
-
-    expect(received).to.have.length(0);
-  });
-
-  it("clears the subscriptions when the node types are unregistered", async () => {
-    const received: EmailEventPayload[] = [];
-    await emailEventTrigger.activate({}, (payload) => {
-      received.push(payload);
-    });
-
-    unregisterAutomationNodes();
-    emitEmailEvent(EVENT);
-
-    expect(received).to.have.length(0);
-  });
-});

package/src/test/unit/categories.test.ts

@@ -1,51 +0,0 @@
-import { expect } from "chai";
-import {
-  parseCategories,
-  reassignRemovedCategories,
-} from "../../services/categories";
-import type { MailingTemplate } from "../../db";
-import type { TemplateCategory } from "../../types";
-
-const CATEGORIES: TemplateCategory[] = [
-  { id: "orders", label: "Orders", icon: "i-ph-package" },
-  { id: "billing", label: "Billing", icon: "i-ph-file-text" },
-];
-
-const template = (id: string, category?: string): MailingTemplate =>
-  ({ _id: id, category }) as MailingTemplate;
-
-describe("[unit] services/categories parseCategories", () => {
-  it("reads the list the form field stores, as a string or an array", () => {
-    expect(parseCategories(JSON.stringify(CATEGORIES))).to.deep.equal(
-      CATEGORIES,
-    );
-    expect(parseCategories(CATEGORIES)).to.deep.equal(CATEGORIES);
-  });
-
-  it("answers an empty list for blank or broken input", () => {
-    expect(parseCategories("")).to.deep.equal([]);
-    expect(parseCategories("not json")).to.deep.equal([]);
-    expect(parseCategories(undefined)).to.deep.equal([]);
-  });
-});
-
-describe("[unit] services/categories reassignRemovedCategories", () => {
-  it("names the templates whose category no longer exists", () => {
-    const templates = [
-      template("a", "orders"),
-      template("b", "gone"),
-      template("c"),
-      template("d", "gone"),
-    ];
-    expect(reassignRemovedCategories(templates, CATEGORIES)).to.deep.equal([
-      "b",
-      "d",
-    ]);
-  });
-
-  it("names nothing when every category survives", () => {
-    expect(
-      reassignRemovedCategories([template("a", "orders")], CATEGORIES),
-    ).to.deep.equal([]);
-  });
-});

package/src/test/unit/engine/conditions.test.ts

@@ -1,35 +0,0 @@
-import { expect } from "chai";
-import { evaluateCondition } from "../../../engine";
-import type { Condition } from "../../../types";
-
-const condition = (operator: Condition["operator"], value = ""): Condition => ({
-  path: "order.total",
-  operator,
-  value,
-});
-
-describe("[unit] engine/conditions", () => {
-  it("treats truthy/falsy with JS semantics and missing as false", () => {
-    expect(
-      evaluateCondition(condition("truthy"), { order: { total: 1 } }),
-    ).to.equal(true);
-    expect(
-      evaluateCondition(condition("truthy"), { order: { total: 0 } }),
-    ).to.equal(false);
-    expect(evaluateCondition(condition("falsy"), {})).to.equal(true);
-  });
-  it("compares as strings for eq/ne and as numbers for gt/lt", () => {
-    expect(
-      evaluateCondition(condition("eq", "42"), { order: { total: 42 } }),
-    ).to.equal(true);
-    expect(
-      evaluateCondition(condition("ne", "42"), { order: { total: "42" } }),
-    ).to.equal(false);
-    expect(
-      evaluateCondition(condition("gt", "10"), { order: { total: 11 } }),
-    ).to.equal(true);
-    expect(
-      evaluateCondition(condition("lt", "10"), { order: { total: "abc" } }),
-    ).to.equal(false);
-  });
-});

package/src/test/unit/engine/coverage.test.ts

@@ -1,118 +0,0 @@
-import { expect } from "chai";
-import {
-  collectContentVariablePaths,
-  collectVariablePaths,
-  missingRequiredVariables,
-} from "../../../engine";
-import type {
-  LocaleContent,
-  TemplateContent,
-  VariableDefinition,
-} from "../../../types";
-
-const CONTENT: LocaleContent = {
-  subject: "Order {{order.ref}}",
-  preheader: "",
-  blocks: [
-    {
-      id: "h",
-      type: "heading",
-      text: "Hi {{customer.firstName}}",
-      align: "left",
-      size: 23,
-      visibleIf: null,
-    },
-    {
-      id: "l",
-      type: "list",
-      source: "order.lines",
-      labelPath: "label",
-      valuePath: "total",
-      visibleIf: null,
-    },
-    {
-      id: "i",
-      type: "if",
-      condition: { path: "order.hasGift", operator: "truthy", value: "" },
-      visibleIf: null,
-      children: [
-        {
-          id: "p",
-          type: "paragraph",
-          text: "{{gift.note}}",
-          align: "left",
-          visibleIf: null,
-        },
-      ],
-      elseChildren: null,
-    },
-    {
-      id: "b",
-      type: "button",
-      text: "Track",
-      href: "{{order.trackUrl}}",
-      align: "left",
-      visibleIf: { path: "order.shipped", operator: "truthy", value: "" },
-    },
-    {
-      id: "f",
-      type: "footer",
-      text: "",
-      unsubscribeLabel: "u",
-      preferencesLabel: "p",
-      visibleIf: null,
-    },
-  ],
-};
-
-describe("[unit] engine/coverage", () => {
-  it("collects every referenced path once, sorted, ignoring list item paths and system paths", () => {
-    expect(collectVariablePaths(CONTENT)).to.deep.equal([
-      "customer.firstName",
-      "gift.note",
-      "order.hasGift",
-      "order.lines",
-      "order.ref",
-      "order.shipped",
-      "order.trackUrl",
-    ]);
-  });
-  it("lists declared required variables missing from a data set", () => {
-    const declared: VariableDefinition[] = [
-      { path: "order.ref", type: "string", required: true },
-      { path: "order.lines[]", type: "array", required: true },
-      { path: "customer.firstName", type: "string", required: false },
-    ];
-    expect(
-      missingRequiredVariables(declared, { order: { ref: "X" } }),
-    ).to.deep.equal(["order.lines"]);
-  });
-});
-
-describe("[unit] engine/coverage across locales", () => {
-  it("unions the paths of every locale, sorted and deduplicated", () => {
-    const french: LocaleContent = {
-      subject: "Commande {{order.ref}}",
-      preheader: "",
-      blocks: [
-        {
-          id: "p",
-          type: "paragraph",
-          text: "Bonjour {{customer.lastName}}",
-          align: "left",
-          visibleIf: null,
-        },
-      ],
-    };
-    const content: TemplateContent = { locales: { en: CONTENT, fr: french } };
-    const paths = collectContentVariablePaths(content);
-    expect(paths).to.include("customer.lastName");
-    expect(paths).to.include("order.ref");
-    expect(paths.filter((path) => path === "order.ref")).to.have.lengthOf(1);
-    expect(paths).to.deep.equal([...paths].sort());
-  });
-
-  it("answers an empty list for content with no locale", () => {
-    expect(collectContentVariablePaths({ locales: {} })).to.deep.equal([]);
-  });
-});

package/src/test/unit/engine/fallback-html.test.ts

@@ -1,86 +0,0 @@
-import { expect } from "chai";
-import { renderFallbackHtml } from "../../../engine";
-import type { ResolvedEmail } from "../../../types";
-
-const EMAIL: ResolvedEmail = {
-  subject: "Hello",
-  preheader: "Pre",
-  missing: [],
-  hiddenBlockIds: [],
-  blocks: [
-    { id: "h", type: "heading", text: "Hi <Sofie>", align: "left", size: 23 },
-    {
-      id: "b",
-      type: "button",
-      text: "Go",
-      href: "https://x.test/?a=1&b=2",
-      align: "center",
-    },
-    { id: "l", type: "list", rows: [{ label: "Chair", value: "64" }] },
-    {
-      id: "f",
-      type: "footer",
-      text: "Antelope",
-      unsubscribeLabel: "Unsub",
-      preferencesLabel: "Prefs",
-      unsubscribeUrl: "https://u",
-      preferencesUrl: "",
-    },
-  ],
-};
-
-describe("[unit] engine/fallback-html", () => {
-  const html = renderFallbackHtml(EMAIL, "en");
-  it("produces a full document with the subject as title and escaped content", () => {
-    expect(html).to.match(/^<!DOCTYPE html>/);
-    expect(html).to.include("<title>Hello</title>");
-    expect(html).to.include("Hi &lt;Sofie&gt;");
-    expect(html).to.include('href="https://x.test/?a=1&amp;b=2"');
-  });
-  it("renders list rows and only the footer links that have a url", () => {
-    expect(html).to.include("Chair");
-    expect(html).to.include('href="https://u"');
-    expect(html).to.not.include("Prefs");
-  });
-});
-
-const withHref = (href: string): ResolvedEmail => ({
-  subject: "S",
-  preheader: "P",
-  missing: [],
-  hiddenBlockIds: [],
-  blocks: [{ id: "b", type: "button", text: "Go", href, align: "left" }],
-});
-
-describe("[unit] engine/fallback-html link schemes", () => {
-  // A link target can come straight from an interpolated variable, so it is
-  // recipient-supplied data. Escaping the entities is not enough: the scheme
-  // itself has to be one a mail client may follow.
-  it("keeps the schemes an e-mail legitimately uses", () => {
-    for (const href of [
-      "https://x.test/a?b=1",
-      "http://x.test",
-      "mailto:a@b.test",
-      "/relative/path",
-      "{{order.trackUrl}}",
-    ]) {
-      expect(renderFallbackHtml(withHref(href), "en")).to.contain("href=");
-      expect(renderFallbackHtml(withHref(href), "en")).to.not.contain(
-        'href="#"',
-      );
-    }
-  });
-
-  it("neutralises a scheme that carries code", () => {
-    for (const href of [
-      "javascript:alert(1)",
-      "JavaScript:alert(1)",
-      " javascript:alert(1)",
-      "data:text/html,<script>alert(1)</script>",
-      "vbscript:msgbox",
-    ]) {
-      expect(renderFallbackHtml(withHref(href), "en")).to.contain('href="#"');
-      expect(renderFallbackHtml(withHref(href), "en")).to.not.contain("alert");
-    }
-  });
-});

package/src/test/unit/engine/paths.test.ts

@@ -1,39 +0,0 @@
-import { expect } from "chai";
-import { getPath, normalizePath } from "../../../engine";
-
-const DATA = {
-  order: { ref: "CMD-1", lines: [{ label: "A" }] },
-  customer: { firstName: "Sofie" },
-};
-
-describe("[unit] engine/paths", () => {
-  it("reads nested values", () => {
-    expect(getPath(DATA, "order.ref")).to.equal("CMD-1");
-    expect(getPath(DATA, "order.lines")).to.deep.equal([{ label: "A" }]);
-  });
-  it("returns undefined for missing segments without throwing", () => {
-    expect(getPath(DATA, "order.missing.deep")).to.equal(undefined);
-    expect(getPath(null, "a")).to.equal(undefined);
-  });
-  it("strips the array suffix used in declarations", () => {
-    expect(normalizePath("order.lines[]")).to.equal("order.lines");
-  });
-});
-
-describe("[unit] engine/paths reserved keys", () => {
-  // A token path is authored, not recipient-supplied, but `{{constructor}}`
-  // still resolved to the Object constructor and String()'d its source into the
-  // e-mail. Nothing legitimate walks through these.
-  it("refuses to walk the prototype chain", () => {
-    expect(getPath({ a: 1 }, "constructor")).to.equal(undefined);
-    expect(getPath({ a: 1 }, "__proto__")).to.equal(undefined);
-    expect(getPath({ a: 1 }, "prototype")).to.equal(undefined);
-    expect(
-      getPath({ a: { __proto__: { leaked: 1 } } }, "a.__proto__"),
-    ).to.equal(undefined);
-  });
-
-  it("still reads an ordinary path", () => {
-    expect(getPath({ a: { b: 2 } }, "a.b")).to.equal(2);
-  });
-});

package/src/test/unit/engine/resolve.test.ts

@@ -1,176 +0,0 @@
-import { expect } from "chai";
-import { resolveEmail } from "../../../engine";
-import type { LocaleContent } from "../../../types";
-
-const CONTENT: LocaleContent = {
-  subject: "Order {{order.ref}}",
-  preheader: "Thanks {{customer.firstName}}",
-  blocks: [
-    {
-      id: "h",
-      type: "heading",
-      text: "Thanks {{customer.firstName}}",
-      align: "left",
-      size: 23,
-      visibleIf: null,
-    },
-    {
-      id: "l",
-      type: "list",
-      source: "order.lines",
-      labelPath: "label",
-      valuePath: "total",
-      visibleIf: null,
-    },
-    {
-      id: "t",
-      type: "total",
-      label: "Total",
-      value: "{{order.total}}",
-      visibleIf: null,
-    },
-    {
-      id: "i",
-      type: "if",
-      condition: { path: "order.hasGift", operator: "truthy", value: "" },
-      visibleIf: null,
-      children: [
-        {
-          id: "gift",
-          type: "paragraph",
-          text: "Gift inside",
-          align: "left",
-          visibleIf: null,
-        },
-      ],
-      elseChildren: [
-        {
-          id: "nogift",
-          type: "paragraph",
-          text: "No gift",
-          align: "left",
-          visibleIf: null,
-        },
-      ],
-    },
-    {
-      id: "b",
-      type: "button",
-      text: "Track",
-      href: "{{order.trackUrl}}",
-      align: "center",
-      visibleIf: { path: "order.shipped", operator: "truthy", value: "" },
-    },
-    {
-      id: "f",
-      type: "footer",
-      text: "Antelope",
-      unsubscribeLabel: "Unsubscribe",
-      preferencesLabel: "Preferences",
-      visibleIf: null,
-    },
-  ],
-};
-
-const DATA = {
-  customer: { firstName: "Sofie" },
-  order: {
-    ref: "CMD-1",
-    total: "70,50 €",
-    hasGift: true,
-    lines: [
-      { label: "Chair", total: "64" },
-      { label: "Shipping", total: "6,50" },
-    ],
-  },
-  unsubscribeUrl: "https://u",
-};
-
-describe("[unit] engine/resolve", () => {
-  const email = resolveEmail(CONTENT, DATA);
-  it("interpolates subject and preheader", () => {
-    expect(email.subject).to.equal("Order CMD-1");
-    expect(email.preheader).to.equal("Thanks Sofie");
-  });
-  it("expands lists, picks the if branch and flattens it", () => {
-    expect(email.blocks.map((block) => block.id)).to.deep.equal([
-      "h",
-      "l",
-      "t",
-      "gift",
-      "f",
-    ]);
-    const list = email.blocks[1]!;
-    expect(list.type === "list" && list.rows).to.deep.equal([
-      { label: "Chair", value: "64" },
-      { label: "Shipping", value: "6,50" },
-    ]);
-  });
-  it("hides blocks whose visibleIf is false and reports them", () => {
-    expect(email.hiddenBlockIds).to.deep.equal(["nogift", "b"]);
-  });
-  // The only unresolved user path in this fixture is the tracking URL of the
-  // button, which `order.shipped` hides — so it is not reported. The two
-  // directions of that rule are covered below.
-  it("resolves the footer's system urls without reporting them missing", () => {
-    expect(email.missing).to.deep.equal([]);
-    const footer = email.blocks[4]!;
-    expect(footer.type === "footer" && footer.unsubscribeUrl).to.equal(
-      "https://u",
-    );
-    expect(footer.type === "footer" && footer.preferencesUrl).to.equal("");
-  });
-});
-
-describe("[unit] engine/resolve hidden blocks", () => {
-  const hiddenParagraph = {
-    subject: "S",
-    preheader: "",
-    blocks: [
-      {
-        id: "p1",
-        type: "paragraph" as const,
-        align: "left" as const,
-        text: "A gift: {{order.giftMessage}}",
-        visibleIf: {
-          path: "order.hasGift",
-          operator: "truthy" as const,
-          value: "",
-        },
-      },
-    ],
-  };
-
-  // `blockOnMissingVariables` refuses a send whose resolved e-mail reports a
-  // missing variable. A block the condition hides is never rendered, so what it
-  // references must not count — otherwise conditional content makes that
-  // setting unusable.
-  it("does not report a variable only a hidden block references", () => {
-    const email = resolveEmail(hiddenParagraph, { order: { hasGift: false } });
-    expect(email.blocks).to.have.lengthOf(0);
-    expect(email.hiddenBlockIds).to.deep.equal(["p1"]);
-    expect(email.missing).to.deep.equal([]);
-  });
-
-  it("still reports it when the block is shown", () => {
-    const email = resolveEmail(hiddenParagraph, { order: { hasGift: true } });
-    expect(email.blocks).to.have.lengthOf(1);
-    expect(email.missing).to.deep.equal(["order.giftMessage"]);
-  });
-});
-
-describe("[unit] engine/resolve system variables", () => {
-  // `unsubscribeUrl` and `preferencesUrl` are filled by the runtime, so a
-  // template referencing one must not ask the author to declare it.
-  it("keeps system paths out of the missing list, unlike user paths", () => {
-    const email = resolveEmail(
-      {
-        subject: "{{unsubscribeUrl}} {{preferencesUrl}} {{order.ref}}",
-        preheader: "",
-        blocks: [],
-      },
-      {},
-    );
-    expect(email.missing).to.deep.equal(["order.ref"]);
-  });
-});

package/src/test/unit/engine/tokens.test.ts

@@ -1,26 +0,0 @@
-import { expect } from "chai";
-import { extractTokens, interpolate } from "../../../engine";
-
-describe("[unit] engine/tokens", () => {
-  it("extracts unique trimmed token paths in order", () => {
-    expect(
-      extractTokens("Hi {{ customer.firstName }}, {{order.ref}} {{order.ref}}"),
-    ).to.deep.equal(["customer.firstName", "order.ref"]);
-  });
-  it("interpolates known paths and reports missing ones", () => {
-    const result = interpolate("Hi {{customer.firstName}}, ref {{order.ref}}", {
-      customer: { firstName: "Sofie" },
-    });
-    expect(result.text).to.equal("Hi Sofie, ref {{order.ref}}");
-    expect(result.missing).to.deep.equal(["order.ref"]);
-  });
-  it("renders numbers and booleans as text and treats null as missing", () => {
-    const result = interpolate("{{count}}-{{flag}}-{{nothing}}", {
-      count: 3,
-      flag: false,
-      nothing: null,
-    });
-    expect(result.text).to.equal("3-false-{{nothing}}");
-    expect(result.missing).to.deep.equal(["nothing"]);
-  });
-});

package/src/test/unit/events.test.ts

@@ -1,19 +0,0 @@
-import { expect } from "chai";
-import { applyEvent } from "../../services/events";
-
-describe("[unit] services/events", () => {
-  it("promotes the status forward only and counts opens/clicks", () => {
-    expect(
-      applyEvent({ status: "sent", opens: 0, clicks: 0 }, "opened"),
-    ).to.deep.equal({ status: "opened", opens: 1, clicks: 0 });
-    expect(
-      applyEvent({ status: "clicked", opens: 1, clicks: 1 }, "opened"),
-    ).to.deep.equal({ status: "clicked", opens: 2, clicks: 1 });
-    expect(
-      applyEvent({ status: "delivered", opens: 0, clicks: 0 }, "bounced"),
-    ).to.deep.equal({ status: "bounced", opens: 0, clicks: 0 });
-    expect(
-      applyEvent({ status: "bounced", opens: 0, clicks: 0 }, "delivered"),
-    ).to.deep.equal({ status: "bounced", opens: 0, clicks: 0 });
-  });
-});