@antelopejs/dms-mailing 0.7.1 → 0.9.0

package/src/services/catalog.ts

@@ -1,21 +1,17 @@
 import { readFileSync } from "node:fs";
 import path from "node:path";
 import type { ModuleStatus } from "@antelopejs/interface-dms/page";
+import { isText } from "../validation/guards";
+import { parseJsonObject } from "../validation/json";
 import { readCapabilities } from "./provider";
 
 const PACKAGE_JSON_PATH = path.join(__dirname, "../../package.json");
 
-interface PackageManifest {
-  version?: string;
-}
-
 /** The module's published version, as the catalog tile and the sidebar show it. */
 export function moduleVersion(): string | undefined {
   try {
-    const manifest = JSON.parse(
-      readFileSync(PACKAGE_JSON_PATH, "utf8"),
-    ) as PackageManifest;
-    return manifest.version;
+    const manifest = parseJsonObject(readFileSync(PACKAGE_JSON_PATH, "utf8"));
+    return isText(manifest.version) ? manifest.version : undefined;
   } catch {
     return undefined;
   }

package/src/services/categories.ts

@@ -48,10 +48,10 @@ export function reassignRemovedCategories(
   moves: ReadonlyMap<string, string> = new Map(),
 ): CategoryReassignment[] {
   const kept = new Set(categories.map((category) => category.id));
-  return templates
-    .filter((template) => template.category && !kept.has(template.category))
-    .map((template) => ({
-      templateId: template._id,
-      category: moves.get(template.category as string) ?? "",
-    }));
+  return templates.flatMap((template) => {
+    const { category } = template;
+    return category && !kept.has(category)
+      ? [{ templateId: template._id, category: moves.get(category) ?? "" }]
+      : [];
+  });
 }

package/src/services/checked-send.ts

@@ -10,6 +10,7 @@ import {
   sendTemplate,
 } from "./send";
 import { suppressionsOf } from "./suppressions";
+import { isText } from "../validation/guards";
 
 /**
  * A send the module checks against the suppression list. `allowSuppressed`
@@ -24,8 +25,7 @@ export const SUPPRESSED_ERROR_PREFIX = "$dms_mailing.errors.suppressed.";
 
 const NO_LATENCY = null;
 
-const addressOf = (to: EmailAddress): string =>
-  typeof to === "string" ? to : to.email;
+const addressOf = (to: EmailAddress): string => (isText(to) ? to : to.email);
 
 const toRecipients = (to: EmailAddress | EmailAddress[]): EmailAddress[] =>
   Array.isArray(to) ? to : [to];
@@ -68,16 +68,10 @@ function suppressedMessage(
 async function recordSuppressed(
   slug: string,
   params: CheckedSendParams,
-  blocked: EmailAddress[],
-  rows: Map<string, MailingSuppression>,
+  blocked: { to: EmailAddress; row: MailingSuppression }[],
 ): Promise<SendTemplateResult[]> {
   const prepared = await prepare(params.tenantId, slug, params);
-  const messages = blocked.map((to) =>
-    suppressedMessage(
-      to,
-      rows.get(normalizeAddress(addressOf(to))) as MailingSuppression,
-    ),
-  );
+  const messages = blocked.map(({ to, row }) => suppressedMessage(to, row));
   return recordAll(prepared, params, messages);
 }
 
@@ -103,21 +97,25 @@ export async function sendUnlessSuppressed(
   const recipients = toRecipients(params.to);
   const rows = await blockedRecipients(params, recipients);
   if (!rows.size) return sendTemplate(slug, params);
-  const isBlocked = (to: EmailAddress): boolean =>
-    rows.has(normalizeAddress(addressOf(to)));
-  const blocked = recipients.filter(isBlocked);
-  const suppressedResults = await recordSuppressed(slug, params, blocked, rows);
+  const rowOf = (to: EmailAddress) => rows.get(normalizeAddress(addressOf(to)));
+  const isBlocked = (to: EmailAddress): boolean => rowOf(to) !== undefined;
+  const blocked = recipients.flatMap((to) => {
+    const row = rowOf(to);
+    return row ? [{ to, row }] : [];
+  });
+  const suppressedResults = await recordSuppressed(slug, params, blocked);
   const sentResults = await sendAllowed(
     slug,
     params,
     recipients.filter((to) => !isBlocked(to)),
   );
+  let nextSuppressed = 0;
+  let nextSent = 0;
   return aggregateResults(
-    recipients.map(
-      (to) =>
-        (isBlocked(to)
-          ? suppressedResults.shift()
-          : sentResults.shift()) as SendTemplateResult,
+    recipients.map((to) =>
+      isBlocked(to)
+        ? suppressedResults[nextSuppressed++]
+        : sentResults[nextSent++],
     ),
   );
 }

package/src/services/declaration-error.ts

@@ -26,7 +26,7 @@ function describeIssues(error: ZodError): string {
 /** `input` parsed by `schema`, or a `DeclarationError` under `code`. */
 export function parseDeclared<Output, Input>(
   schema: ZodType<Output, ZodTypeDef, Input>,
-  input: unknown,
+  input: Input,
   code: string,
   subject: string,
 ): Output {

package/src/services/declarations.ts

@@ -93,16 +93,14 @@ async function createDeclared(
       ...publishedAtCreation(
         randomUUID(),
         {
-          content: declaration.content as TemplateContent,
+          content: declaration.content,
           variables: declaration.variables,
         },
         author,
       ),
     });
-    template = await requireTemplate(model, id as string);
+    template = await requireTemplate(model, id);
   } catch (error) {
-    // A concurrent declaration of the slug created it first: expected, the
-    // caller goes on with that template.
     if (IsDuplicateKeyError(error)) return undefined;
     throw error;
   }
@@ -127,7 +125,7 @@ export async function declareTemplate(
     `template declaration "${String(input?.slug)}"`,
   );
   const { tenantId, slug } = declaration;
-  assertPublishable(declaration.content as TemplateContent, slug);
+  assertPublishable(declaration.content, slug);
   const model = GetModel(TemplateModel, tenantId);
   const existing = await model.getBySlug(slug);
   if (existing) return resultOf(existing, "kept");
@@ -135,7 +133,10 @@ export async function declareTemplate(
   assertKnownCategory(settings.categories, declaration.category, slug);
   const created = await createDeclared(declaration);
   if (created) return resultOf(created, "created");
-  return resultOf((await model.getBySlug(slug)) as MailingTemplate, "kept");
+  const winner = await model.getBySlug(slug);
+  if (!winner)
+    throw new Error(`Template "${slug}" disappeared before it was read`);
+  return resultOf(winner, "kept");
 }
 
 /** Category declarations of one tenant run one after the other. */

package/src/services/events.ts

@@ -16,6 +16,8 @@ import { publishSendUpdated } from "../realtime";
 import type { SendEventType, SendStatus } from "../types";
 import { notifyProblems } from "./notify";
 import { suppressAddress, suppressionReasonOf } from "./suppressions";
+import { isText } from "../validation/guards";
+import { isJsonObject } from "../validation/json";
 
 export interface SendCounters {
   status: SendStatus;
@@ -59,8 +61,11 @@ const HARD_BOUNCE_TYPE = /hard|permanent/i;
 /** A temporary SMTP answer: a `4xx` reply code or a `4.x.x` enhanced status. */
 const SOFT_SMTP_ANSWER = /^\s*4\d\d\b|\b4\.\d{1,3}\.\d{1,3}\b/;
 
-const textOf = (value: unknown): string =>
-  typeof value === "string" ? value : "";
+/** The text an event's details hold under `key`, else an empty string. */
+function textOf(details: EmailEvent["details"], key: string): string {
+  const value = details?.[key];
+  return isText(value) ? value : "";
+}
 
 /**
  * The provider's own words for a problem event (`550 5.1.1 Mailbox does not
@@ -70,7 +75,7 @@ const textOf = (value: unknown): string =>
 export function problemReason(event: EmailEvent): string | undefined {
   if (!PROBLEM_EVENTS.has(event.type)) return undefined;
   const reason = event.details?.reason;
-  return typeof reason === "string" && reason ? reason : undefined;
+  return isText(reason) && reason ? reason : undefined;
 }
 
 function overridesStatus(current: SendStatus, next: SendStatus): boolean {
@@ -95,10 +100,10 @@ export function applyEvent(
  * provider's `bounceType` when it gives one, else the SMTP answer's class.
  */
 export function isSoftBounce(event: EmailEvent): boolean {
-  const bounceType = textOf(event.details?.bounceType);
+  const bounceType = textOf(event.details, "bounceType");
   if (SOFT_BOUNCE_TYPE.test(bounceType)) return true;
   if (HARD_BOUNCE_TYPE.test(bounceType)) return false;
-  return SOFT_SMTP_ANSWER.test(textOf(event.details?.reason));
+  return SOFT_SMTP_ANSWER.test(textOf(event.details, "reason"));
 }
 
 /**
@@ -144,8 +149,8 @@ async function publishEmailEvent(
   });
 }
 
-const eventIdOf = (details: Record<string, unknown> | undefined): string =>
-  textOf(details?.eventId);
+const eventIdOf = (details: EmailEvent["details"]): string =>
+  textOf(details, "eventId");
 
 type StoredEventIdentity = Pick<
   MailingSendEvent,
@@ -163,11 +168,11 @@ export function isSameEvent(
 ): boolean {
   const eventId = eventIdOf(event.details);
   if (eventId) {
-    const storedDetails = JSON.parse(stored.json_details || "{}") as Record<
-      string,
-      unknown
-    >;
-    return eventIdOf(storedDetails) === eventId;
+    const storedDetails: unknown = JSON.parse(stored.json_details || "{}");
+    return (
+      eventIdOf(isJsonObject(storedDetails) ? storedDetails : undefined) ===
+      eventId
+    );
   }
   if (!event.at || stored.type !== event.type) return false;
   return (
@@ -223,7 +228,7 @@ async function suppressAfterEvent(
       email: send.recipientEmail,
       reason,
       sendId: send._id,
-      detail: textOf(event.details?.reason) || undefined,
+      detail: textOf(event.details, "reason") || undefined,
     });
   } catch (error) {
     Logging.Error("[dms-mailing] Could not suppress an address:", error);

package/src/services/localized-text.ts

@@ -1,8 +1,10 @@
+import type { IncomingHttpHeaders } from "node:http";
 import type { RequestContext } from "@antelopejs/interface-api";
 import {
   LOCALIZED_TEXT_FALLBACK_LOCALE,
   type LocalizedText,
 } from "@antelopejs/interface-dms-mailing";
+import { isText } from "../validation/guards";
 
 /** Header the DMS frontend states the reader's language in on every request. */
 export const CONTENT_LANGUAGE_HEADER = "x-content-language";
@@ -13,8 +15,8 @@ export const CONTENT_LANGUAGE_HEADER = "x-content-language";
  *
  * @param header Value of {@link CONTENT_LANGUAGE_HEADER}
  */
-export function requestLocale(header: unknown): string {
-  return typeof header === "string" && header.length > 0
+export function requestLocale(header: IncomingHttpHeaders[string]): string {
+  return isText(header) && header.length > 0
     ? header
     : LOCALIZED_TEXT_FALLBACK_LOCALE;
 }

package/src/services/metrics.ts

@@ -11,14 +11,12 @@ const AUDIENCE_KEEPS: Record<SendAudience, (send: SendSummary) => boolean> = {
   [OPERATIONAL_AUDIENCE]: () => true,
 };
 
-const AUDIENCE_BY_NAME: Record<string, SendAudience> = {
-  [BUSINESS_AUDIENCE]: BUSINESS_AUDIENCE,
-  [OPERATIONAL_AUDIENCE]: OPERATIONAL_AUDIENCE,
-};
+const isAudience = (raw: string): raw is SendAudience =>
+  Object.hasOwn(AUDIENCE_KEEPS, raw);
 
 /** Named audience behind a query value; anything unknown is the business view. */
 export function readAudience(raw: string | null | undefined): SendAudience {
-  return AUDIENCE_BY_NAME[raw ?? ""] ?? BUSINESS_AUDIENCE;
+  return raw != null && isAudience(raw) ? raw : BUSINESS_AUDIENCE;
 }
 
 const STATS_WINDOW_DAYS = 30;
@@ -122,7 +120,7 @@ const wasOpened = (send: SendSummary): boolean =>
 function median(values: number[]): number {
   if (!values.length) return 0;
   const sorted = [...values].sort((left, right) => left - right);
-  return sorted[Math.floor(sorted.length / 2)] as number;
+  return sorted[Math.floor(sorted.length / 2)];
 }
 
 /** A send to a suppressed address never left: no figure counts it. */
@@ -262,7 +260,7 @@ export function alignSeries(
   axis: SeriesPoint[],
 ): SeriesPoint[] {
   return points.slice(0, axis.length).map((point, index) => ({
-    x: (axis[index] as SeriesPoint).x,
+    x: axis[index].x,
     y: point.y,
   }));
 }

package/src/services/notify.ts

@@ -38,7 +38,7 @@ const PERCENT = 100;
 const SENDS_PAGE = "/modules/mailing/sends";
 const PROBLEMS_VIEW = "problems";
 const IDEMPOTENCY_KEY_SEPARATOR = ":";
-// The DMS keys notifications across every module: ours carry the module's name.
+/** The DMS keys notifications across every module: ours carry the module's name. */
 const IDEMPOTENCY_KEY_PREFIX = "mailing:problems";
 const PROBLEMS_ICON = "i-ph-warning";
 const PROBLEMS_TITLE = "$dms_mailing.notifications.problems_title";

package/src/services/render.ts

@@ -17,13 +17,17 @@ export interface MailingEmailProps {
 const MailingEmailTemplate =
   RegisterHtmlTemplate<MailingEmailProps>(EMAIL_TEMPLATE_NAME);
 
+/**
+ * The HTML of `email`: through the DMS renderer, which already drops Vue's
+ * SSR markers (dms-frontend 0.5.4), else the module's fallback HTML when the
+ * configuration turns HTML rendering off or the renderer fails.
+ */
 export async function renderEmailHtml(
   email: ResolvedEmail,
   locale: string,
 ): Promise<string> {
   if (!getConfig().useHtmlRender) return renderFallbackHtml(email, locale);
   try {
-    // The DMS renderer already drops Vue's SSR markers (dms-frontend 0.5.4).
     return await GenerateHtml(MailingEmailTemplate, { locale, email });
   } catch (error) {
     Logging.Warn(

package/src/services/send-import.ts

@@ -27,6 +27,7 @@ import {
 } from "./events";
 import { getSettings } from "./settings";
 import { refreshTemplateAttention } from "./template-attention";
+import { isText } from "../validation/guards";
 
 /** Labels an imported send in the log when its caller gives no source. */
 const IMPORT_SOURCE = "import";
@@ -47,7 +48,7 @@ function importedSendIdOf(tenantId: string, importId: string): string {
 }
 
 const addressOf = (to: ParsedImportedSend["to"]) =>
-  typeof to === "string" ? { email: to } : to;
+  isText(to) ? { email: to } : to;
 
 /** Chronological events, with the webhook's retry deduplication rules. */
 function timelineOf(send: ParsedImportedSend): ImportedEvent[] {
@@ -59,11 +60,11 @@ function timelineOf(send: ParsedImportedSend): ImportedEvent[] {
     const repeated = timeline.some((stored) =>
       isSameEvent(
         {
-          type: stored.type as SendEventType,
+          type: stored.type,
           at: stored.at,
           json_details: JSON.stringify(stored.details ?? {}),
         },
-        { ...entry, type: entry.type as SendEventType },
+        entry,
       ),
     );
     if (!repeated) timeline.push(entry);
@@ -87,7 +88,7 @@ function foldEvents(
       const event: EmailEvent = {
         provider: send.provider ?? IMPORT_SOURCE,
         messageId: send.providerMessageId ?? "",
-        type: entry.type as SendEventType,
+        type: entry.type,
         at: entry.at,
         details: entry.details,
       };
@@ -141,6 +142,13 @@ function sendRow(
   };
 }
 
+/** The refusal of an import that names a template the workspace lacks. */
+const missingTemplate = (slug: string): DeclarationError =>
+  new DeclarationError(
+    "template_not_found",
+    `Imported sends name template "${slug}", which the workspace does not have`,
+  );
+
 /** The templates the sends name, by slug; refused before anything is written. */
 async function templatesOf(
   tenantId: string,
@@ -151,11 +159,7 @@ async function templatesOf(
   const templates = new Map<string, MailingTemplate>();
   for (const slug of slugs) {
     const template = await model.getBySlug(slug);
-    if (!template)
-      throw new DeclarationError(
-        "template_not_found",
-        `Imported sends name template "${slug}", which the workspace does not have`,
-      );
+    if (!template) throw missingTemplate(slug);
     templates.set(slug, template);
   }
   return templates;
@@ -187,7 +191,7 @@ async function importOne(
     await events.insertImported({
       _id: `${id}-${index}`,
       sendId: id,
-      type: entry.type as SendEventType,
+      type: entry.type,
       at: entry.at,
       json_details: JSON.stringify(entry.details ?? {}),
     });
@@ -219,7 +223,8 @@ export async function importSends(
   const { fallbackLocale } = await getSettings(tenantId);
   const result: ImportSendsResult = { imported: 0, skipped: 0, sendIds: [] };
   for (const send of sends) {
-    const template = templates.get(send.templateSlug) as MailingTemplate;
+    const template = templates.get(send.templateSlug);
+    if (!template) throw missingTemplate(send.templateSlug);
     const { id, isImported } = await importOne(
       tenantId,
       send,

package/src/services/send.ts

@@ -52,6 +52,7 @@ import {
   type VersionedSnapshot,
   workingSnapshot,
 } from "./templates";
+import { isText } from "../validation/guards";
 
 export class SendError extends Error {
   constructor(
@@ -158,14 +159,10 @@ const OUTCOME_SEVERITY: Record<SendStatus, number> = {
   failed: 9,
 };
 
-const describeError = (error: unknown): string =>
-  error instanceof Error ? error.message : String(error);
-
-const addressOf = (to: EmailAddress): string =>
-  typeof to === "string" ? to : to.email;
+const addressOf = (to: EmailAddress): string => (isText(to) ? to : to.email);
 
 const nameOf = (to: EmailAddress): string | undefined =>
-  typeof to === "string" ? undefined : to.name;
+  isText(to) ? undefined : to.name;
 
 const toRecipients = (to: EmailAddress | EmailAddress[]): EmailAddress[] =>
   Array.isArray(to) ? to : [to];
@@ -376,7 +373,7 @@ async function deliverOne(
       status: "failed",
       outcome: {
         latencyMs: Date.now() - startedAt,
-        error: describeError(error),
+        error: error instanceof Error ? error.message : String(error),
       },
     };
   }
@@ -423,7 +420,7 @@ export async function deliverBatch(
     return failAll(
       input.recipients,
       Date.now() - startedAt,
-      describeError(error),
+      error instanceof Error ? error.message : String(error),
     );
   }
 }
@@ -468,15 +465,15 @@ async function record(
     isTest: Boolean(params.isTest),
   });
   await GetModel(SendEventModel, tenantId).insertForActiveSend({
-    sendId: sendId as string,
+    sendId,
     type: status,
     at: new Date(),
     json_details: JSON.stringify(
       outcome.error ? { reason: outcome.error } : {},
     ),
   });
-  publishSendCreated(tenantId, sendId as string);
-  return sendId as string;
+  publishSendCreated(tenantId, sendId);
+  return sendId;
 }
 
 async function recordOne(
@@ -504,7 +501,7 @@ async function recordOne(
       sendId: UNRECORDED_SEND_ID,
       status: "failed",
       messageId: message.outcome.providerMessageId,
-      error: describeError(error),
+      error: error instanceof Error ? error.message : String(error),
     };
   }
 }
@@ -525,7 +522,7 @@ export async function recordAll(
 export function aggregateResults(
   results: SendTemplateResult[],
 ): SendTemplateResult {
-  const first = results[0] as SendTemplateResult;
+  const first = results[0];
   const worst = results.reduce((left, right) =>
     OUTCOME_SEVERITY[right.status] > OUTCOME_SEVERITY[left.status]
       ? right

package/src/services/settings.ts

@@ -6,6 +6,8 @@ import {
   type MailingSettingsValues,
   type TemplateCategory,
 } from "../types";
+import type { JsonObject } from "../types/json";
+import type { SettingsPatch } from "../validation/settings.schema";
 
 export const WEBHOOK_SECRET_BYTES = 24;
 
@@ -28,6 +30,8 @@ function toValues(row: MailingSettings): MailingSettingsValues {
     senderEmail: row.senderEmail,
     replyTo: row.replyTo,
     webhookSecret: row.webhookSecret,
+    // SAFETY: json_categories is written only by toRow as the JSON.stringify of categories that categoriesSchema
+    // validated (settingsPatchSchema, applyCategory) or that the module defaults supplied.
     categories: JSON.parse(row.json_categories) as TemplateCategory[],
   };
 }
@@ -71,7 +75,12 @@ export async function getSettings(
   if (existing) return existing;
   const created = defaults();
   if (await insertKeyedSettings(tenantId, created)) return created;
-  return (await findSettings(tenantId)) as MailingSettingsValues;
+  const winner = await findSettings(tenantId);
+  if (!winner)
+    throw new Error(
+      `The settings of tenant "${tenantId}" disappeared before they were read`,
+    );
+  return winner;
 }
 
 export async function saveSettings(
@@ -105,36 +114,28 @@ export function missingVariablesPolicy(
 }
 
 /** The form-only field folded back into `blockOnMissingVariables`. */
-const MISSING_VARIABLES_KEY = "missingVariables";
 const CLEARED_VALUE = "";
 /** The patch with each cleared field (`null`) as the empty value it stores. */
-export function clearedToEmpty(
-  patch: Record<string, unknown>,
-): Record<string, unknown> {
+export function clearedToEmpty(patch: JsonObject): JsonObject {
   return Object.fromEntries(
     Object.entries(patch).map(([key, value]) => [key, value ?? CLEARED_VALUE]),
   );
 }
 
 /**
- * The settings once `patch` (the fields a form changed, `null` for a cleared
- * one) is laid over the stored ones, the missing-variables choice folded back
- * into its boolean.
+ * The settings once `patch` (the fields a form changed, cleared ones already
+ * stored as empty) is laid over the stored ones, the missing-variables choice
+ * folded back into its boolean.
  */
 export function mergeSettingsPatch(
   current: MailingSettingsValues,
-  patch: Record<string, unknown>,
+  patch: SettingsPatch,
 ): MailingSettingsValues {
-  const written = Object.fromEntries(
-    Object.entries(clearedToEmpty(patch)).filter(
-      ([key]) => key !== MISSING_VARIABLES_KEY,
-    ),
-  );
-  const policy = patch.missingVariables;
+  const { missingVariables: policy, ...written } = patch;
   const isChoice = policy === REFUSE_POLICY || policy === SEND_POLICY;
   const guard =
     isChoice && !("blockOnMissingVariables" in patch)
       ? { blockOnMissingVariables: policy === REFUSE_POLICY }
       : {};
-  return { ...current, ...written, ...guard } as MailingSettingsValues;
+  return { ...current, ...written, ...guard };
 }

package/src/services/starters.ts

@@ -5,6 +5,7 @@ import type {
   TemplateContent,
   VariableDefinition,
 } from "../types";
+import type { JsonObject } from "../types/json";
 import { footerForCategory, formattingLocale } from "../engine";
 import { blankFields, footerBlock } from "./templates";
 
@@ -21,9 +22,9 @@ export interface StarterTemplate {
   content: TemplateContent;
   variables: VariableDefinition[];
   /** The test data as an English-speaking workspace gets it. */
-  testData: Record<string, unknown>;
+  testData: JsonObject;
   /** The test data with its amounts written the way `locale` writes them. */
-  testDataFor: (locale: string) => Record<string, unknown>;
+  testDataFor: (locale: string) => JsonObject;
 }
 
 type StarterSource = Omit<StarterTemplate, "testData">;
@@ -32,16 +33,19 @@ const DEFAULT_TEST_DATA_LOCALE = "en";
 const STARTER_CURRENCY = "EUR";
 
 /** The ordered item of the order starter's test data, by language. */
-const ORDER_LINE_NAMES: Record<string, string> = {
-  en: "Ergo chair · Graphite × 4",
-  fr: "Fauteuil ergonomique · Graphite × 4",
-};
+const ORDER_LINE_NAMES = new Map([
+  [DEFAULT_TEST_DATA_LOCALE, "Ergo chair · Graphite × 4"],
+  ["fr", "Fauteuil ergonomique · Graphite × 4"],
+]);
 const LOCALE_PARTS = /[-_]/;
 
 /** A test text in the language of `locale`, English when it has none. */
-function inLanguageOf(texts: Record<string, string>, locale: string): string {
+function inLanguageOf(
+  texts: ReadonlyMap<string, string>,
+  locale: string,
+): string {
   const language = locale.toLowerCase().split(LOCALE_PARTS)[0] ?? "";
-  return texts[language] ?? (texts[DEFAULT_TEST_DATA_LOCALE] as string);
+  return texts.get(language) ?? texts.get(DEFAULT_TEST_DATA_LOCALE) ?? "";
 }
 
 /** An amount the way `locale` writes it: "€1,556.00", "1 556,00 €". */

package/src/services/template-stats.ts

@@ -66,18 +66,25 @@ export function sourcesOf(sends: SendSummary[]): SourceCount[] {
     .slice(0, MAX_SOURCES);
 }
 
-export function isFallback(send: SendSummary): boolean {
+/** Whether `send` went out in another locale than the one it asked for. */
+function isRequestedFallback(
+  send: SendSummary,
+): send is SendSummary & { requestedLocale: string } {
   return Boolean(send.requestedLocale && send.requestedLocale !== send.locale);
 }
 
+export function isFallback(send: SendSummary): boolean {
+  return isRequestedFallback(send);
+}
+
 export function fallbacksOf(sends: SendSummary[]): FallbackCount[] {
-  const fallbacks = sends.filter(isFallback);
+  const fallbacks = sends.filter(isRequestedFallback);
   return [
     ...groupBy(fallbacks, (send) => `${send.requestedLocale}>${send.locale}`),
   ].map(([, rows]) => {
-    const first = rows[0] as SendSummary;
+    const first = rows[0];
     return {
-      requested: first.requestedLocale as string,
+      requested: first.requestedLocale,
       used: first.locale,
       count: rows.length,
     };