@antelopejs/dms-mailing 0.6.0 → 0.7.0

package/src/data/templates-table.ts

@@ -1,6 +1,7 @@
 import {
   Controller,
   HTTPResult,
+  Parameter,
   type RequestContext,
 } from "@antelopejs/interface-api";
 import { assertValidation } from "@antelopejs/interface-api-util";
@@ -9,6 +10,7 @@ import {
   type DataControllerCallback,
   RegisterDataController,
 } from "@antelopejs/interface-data-api";
+import type { Validation } from "@antelopejs/interface-data-api/components";
 import {
   Access,
   AccessMode,
@@ -17,9 +19,17 @@ import {
   Listable,
   Mandatory,
   ModelReference,
+  ModifierKey,
   Sortable,
 } from "@antelopejs/interface-data-api/metadata";
-import { GetModel } from "@antelopejs/interface-database-decorators";
+import {
+  GetModel,
+  LocalizationModifier,
+} from "@antelopejs/interface-database-decorators";
+import {
+  LOCALIZED_TEXT_FALLBACK_LOCALE,
+  type LocalizedText,
+} from "@antelopejs/interface-dms-mailing";
 import { authenticateTenantRequest } from "@antelopejs/interface-dms/guards";
 import { getRequestTenantId } from "@antelopejs/interface-dms/request-tenant";
 import { TenantScopedModel } from "@antelopejs/interface-dms/tenant-scoped-model";
@@ -48,9 +58,15 @@ import { footerForCategory } from "../engine";
 import {
   MailingTemplate,
   SendModel,
+  type TemplateFields,
   TemplateModel,
   TemplateVersionModel,
 } from "../db";
+import {
+  CONTENT_LANGUAGE_HEADER,
+  localeOfRequest,
+  withTextIn,
+} from "../services/localized-text";
 import { findCategory, getSettings } from "../services/settings";
 import { findStarter, starterFields } from "../services/starters";
 import { refreshTemplateAttention } from "../services/template-attention";
@@ -65,7 +81,10 @@ import {
 } from "../services/templates";
 import type { TemplateCategory } from "../types";
 
-import { createTemplateSchema } from "../validation/templates.schema";
+import {
+  createTemplateSchema,
+  templateDetailsSchema,
+} from "../validation/templates.schema";
 import { parseBody } from "./body";
 import { CategoryDisplay, LocaleChipsDisplay } from "./displays";
 
@@ -116,7 +135,7 @@ async function seedFields(
   tenantId: string,
   seed: TemplateSeed,
   fallbackLocale: string,
-): Promise<Partial<MailingTemplate>> {
+): Promise<TemplateFields> {
   const source = await resolveSource(tenantId, seed.sourceTemplateId);
   if (source) return contentFieldsOf(source);
   if (!seed.starterId) {
@@ -144,23 +163,43 @@ function assertKnownCategory(
   throw new HTTPResult(HTTP_UNPROCESSABLE, UNKNOWN_CATEGORY);
 }
 
-/** The creation's seed, and the body to store: slug and name trimmed. */
-function parseCreation(body: Buffer | string) {
-  const raw = parseBody(body);
+/** The row `new` answers since interface-data-api 0.3: its key and fields. */
+interface CreatedRow {
+  _id: string;
+  [field: string]: unknown;
+}
+
+/**
+ * The creation's seed, and the body to store: slug trimmed, and the name
+ * typed in the reader's language as every language of the localized field,
+ * the fallback one included until someone translates it. A body a guard
+ * already parsed arrives as an object.
+ */
+function parseCreation(body: Validation.WrittenBody, locale: string) {
+  const raw = Buffer.isBuffer(body) ? parseBody(body) : body;
   const seed = assertValidation(
     raw,
     (value) => createTemplateSchema.parse(value),
     () => INVALID_TEMPLATE,
     HTTP_BAD_REQUEST,
   );
-  const normalized = JSON.stringify({
+  // Handed as an object: interface-data-api 0.3 refuses a JSON string.
+  const normalized = {
     ...raw,
     slug: seed.slug,
-    name: seed.name,
-  });
+    name: withTextIn(undefined, locale, seed.name),
+  };
   return { seed, normalized };
 }
 
+/** What the data API locks a localized field with: the controller's key. */
+interface LocalizedController {
+  language: string;
+}
+
+/** The key that writes every language of a localized field at once. */
+const ALL_LANGUAGES = "*";
+
 function withSeeding(base: DataControllerCallback): DataControllerCallback {
   return {
     ...base,
@@ -168,10 +207,10 @@ function withSeeding(base: DataControllerCallback): DataControllerCallback {
       this: unknown,
       ctx: RequestContext,
       params: unknown,
-      body: Buffer | string,
+      body: Validation.WrittenBody,
       ...rest: unknown[]
     ) {
-      const { seed, normalized } = parseCreation(body);
+      const { seed, normalized } = parseCreation(body, localeOfRequest(ctx));
       const tenantId = getRequestTenantId(ctx);
       const model = GetModel(TemplateModel, tenantId);
       if (await model.getBySlug(seed.slug)) {
@@ -180,18 +219,21 @@ function withSeeding(base: DataControllerCallback): DataControllerCallback {
       const settings = await getSettings(tenantId);
       assertKnownCategory(settings.categories, seed.category);
       const fields = await seedFields(tenantId, seed, settings.fallbackLocale);
-      const ids = (await base.func.call(
+      // The module's creation dialogs send one typed name; the stored name
+      // holds every language, written at once.
+      (this as LocalizedController).language = ALL_LANGUAGES;
+      const created = (await base.func.call(
         this,
         ctx,
         params,
         normalized,
         ...rest,
-      )) as string[];
-      const templateId = ids[0] as string;
+      )) as CreatedRow;
+      const templateId = created._id;
       await assertSlugClaimed(tenantId, seed.slug, templateId);
       const user = await authenticateTenantRequest(ctx);
       await initializeTemplate(tenantId, templateId, displayName(user), fields);
-      return ids;
+      return created;
     },
   };
 }
@@ -266,21 +308,78 @@ export async function assertEditable(
 ): Promise<void> {
   if (body.slug !== undefined && body.slug !== current.slug)
     throw new HTTPResult(HTTP_CONFLICT, SLUG_IMMUTABLE);
-  if (typeof body.name === "string" && !body.name.trim())
+  if (body.name !== undefined && isBlankName(body.name))
     throw new HTTPResult(HTTP_BAD_REQUEST, BLANK_NAME);
   const { categories } = await getSettings(tenantId);
   assertKnownCategory(categories, body.category);
 }
 
-/** Stores an edited name trimmed, once the edit is written. */
+/**
+ * Saves what the module's drawer and editor change: the name, typed in the
+ * reader's language (its other languages kept), and the category.
+ */
+export async function saveDetails(
+  ctx: RequestContext,
+  template: MailingTemplate,
+  body: unknown,
+  author: string,
+): Promise<void> {
+  const details = assertValidation(
+    body,
+    (value) => templateDetailsSchema.parse(value),
+    () => INVALID_TEMPLATE,
+  );
+  const tenantId = getRequestTenantId(ctx);
+  await assertEditable(tenantId, details, template);
+  const names = TemplateModel.namesOf(template);
+  await GetModel(TemplateModel, tenantId).updateFields(template._id, {
+    name: withTextIn(names, localeOfRequest(ctx), details.name),
+    ...(details.category !== undefined && {
+      category: details.category ?? "",
+    }),
+    updatedBy: author,
+  });
+}
+
+/**
+ * Whether an edited name holds no text: the text of the reader's language,
+ * or, from a form editing every language, all of them.
+ */
+function isBlankName(name: unknown): boolean {
+  const texts = typeof name === "object" && name ? Object.values(name) : [name];
+  return !texts.some((text) => typeof text === "string" && text.trim());
+}
+
+/** The names trimmed, blank ones left out, the fallback language filled. */
+function tidyNames(names: LocalizedText, locale: string): LocalizedText {
+  const tidy = Object.fromEntries(
+    Object.entries(names)
+      .map(([code, text]) => [code, text.trim()] as const)
+      .filter(([, text]) => text),
+  );
+  if (tidy[LOCALIZED_TEXT_FALLBACK_LOCALE]) return tidy;
+  const [first = ""] = Object.values(tidy);
+  return { ...tidy, [LOCALIZED_TEXT_FALLBACK_LOCALE]: tidy[locale] ?? first };
+}
+
+/**
+ * Once an edit of the name is written, stores it trimmed, and gives the
+ * fallback language a name when it has none, so every reader sees one.
+ */
 export function afterEdit(
   model: TemplateModel,
   id: string,
   name: unknown,
+  locale: string,
 ): AfterWrite | undefined {
-  if (typeof name !== "string" || name === name.trim()) return undefined;
+  if (name === undefined) return undefined;
   return async () => {
-    await model.update(id, { name: name.trim() });
+    const template = await model.get(id);
+    if (!template) return;
+    const names = TemplateModel.namesOf(template);
+    const tidy = tidyNames(names, locale);
+    if (JSON.stringify(tidy) !== JSON.stringify(names))
+      await model.updateFields(id, { name: tidy });
   };
 }
 
@@ -306,6 +405,11 @@ export class TemplatesTableAPI extends DataController(
   @TenantScopedModel(SendModel)
   declare sends: SendModel;
 
+  /** The language names are read, searched, sorted and written in. */
+  @Parameter(CONTENT_LANGUAGE_HEADER, "header")
+  @ModifierKey(LocalizationModifier)
+  declare language: string;
+
   @Select()
   @Listable()
   @Exported()

package/src/db/models/templates.model.ts

@@ -1,5 +1,9 @@
 import { randomUUID } from "node:crypto";
-import { BasicDataModel } from "@antelopejs/interface-database-decorators";
+import {
+  BasicDataModel,
+  triggerEvent,
+} from "@antelopejs/interface-database-decorators";
+import type { LocalizedText } from "@antelopejs/interface-dms-mailing";
 import { MAILING_TEMPLATES_TABLE_NAME, MailingTemplate } from "../tables";
 import { TemplateSlugModel } from "./template-slugs.model";
 
@@ -9,22 +13,76 @@ export type TemplateAttentionFields = Pick<
   "attention" | "needsAttention"
 >;
 
+const isLocalizedText = (value: unknown): value is LocalizedText =>
+  typeof value === "object" &&
+  value !== null &&
+  Object.values(value).every((text) => typeof text === "string");
+
+/** Where a row keeps its modifier-held fields, the localized name among them. */
+const MODIFIER_CONTAINER = "_internal";
+
+/**
+ * Template fields as code writes them: the name holds every language
+ * (`{ en: "Welcome", fr: "Bienvenue" }`).
+ */
+export type TemplateFields = Omit<Partial<MailingTemplate>, "name"> & {
+  name?: LocalizedText;
+};
+
 export class TemplateModel extends BasicDataModel(
   MailingTemplate,
   MAILING_TEMPLATES_TABLE_NAME,
 ) {
+  /** The row of `fields`, its name written in every language it holds. */
+  static fromFields(fields: TemplateFields): MailingTemplate {
+    return TemplateModel.fromPlainData(fields).localize("*", ["name"]);
+  }
+
+  /** The names of `template`, one per language. */
+  static namesOf(template: MailingTemplate): LocalizedText {
+    // Unlocked with "*", the localized field holds the whole per-language record.
+    const names: unknown = template.localize("*", ["name"]).name;
+    return isLocalizedText(names) ? names : {};
+  }
+
+  /** The name of `template` in `locale`, else in the fallback language. */
+  static nameIn(template: MailingTemplate, locale: string): string {
+    return template.localize(locale, ["name"]).name ?? "";
+  }
+
+  /** Inserts a template whose name holds every language. */
+  insertFields(fields: TemplateFields) {
+    return this.insert(TemplateModel.fromFields(fields));
+  }
+
+  /**
+   * Updates a template, a name given holding every language. Every write of
+   * a template goes through here rather than `update`: an update event leaves
+   * the row's modifier container (`_internal`, where the localized name
+   * lives) empty when the patch has no name, and the database merges a row
+   * shallowly, so that empty container would wipe the stored name.
+   */
+  updateFields(id: string, fields: TemplateFields): Promise<number> {
+    const row = TemplateModel.fromFields(fields);
+    triggerEvent(row, "update");
+    const stored = TemplateModel.toDatabase(row);
+    if (fields.name === undefined) delete stored[MODIFIER_CONTAINER];
+    return this.table.get(id).update(stored).run();
+  }
+
   /** Publishes only over the exact semantic revision that was inspected. */
   async publishIfCurrent(
     template: MailingTemplate,
-    patch: Partial<MailingTemplate>,
+    patch: TemplateFields,
   ): Promise<boolean> {
+    const stored = TemplateModel.toDatabase(TemplateModel.fromFields(patch));
     const outcome = await this.table
       .atomicMutation(template._id, {
         type: "update",
         revisionField: "revision",
         expectedRevision: template.revision ?? { kind: "missing" },
         nextRevision: randomUUID(),
-        patch: { ...patch, updatedAt: new Date() },
+        patch: { ...stored, updatedAt: new Date() },
       })
       .run();
     if (outcome === "unknown")

package/src/db/tables/templates.table.ts

@@ -4,18 +4,21 @@ import {
   CreationTime,
   Field,
   Index,
+  LocalizationModifier,
+  Localized,
   Modifier,
   RegisterTable,
   Table,
   UpdateTime,
 } from "@antelopejs/interface-database-decorators";
 import { TENANT_SCHEMA_NAME } from "@antelopejs/interface-dms/constants";
+import { LOCALIZED_TEXT_FALLBACK_LOCALE } from "@antelopejs/interface-dms-mailing";
 import type { TemplateStatus } from "../../types";
 
 export const MAILING_TEMPLATES_TABLE_NAME = "mailing_templates";
 
 @RegisterTable(MAILING_TEMPLATES_TABLE_NAME, TENANT_SCHEMA_NAME)
-export class MailingTemplate extends Table {
+export class MailingTemplate extends Table.with(LocalizationModifier) {
   @Field("string")
   declare _id: string;
 
@@ -32,6 +35,12 @@ export class MailingTemplate extends Table {
   @Field("string")
   declare slug: string;
 
+  /**
+   * One name per language (`{ en: "Welcome", fr: "Bienvenue" }`): read it
+   * after `template.localize(locale, ["name"])`, write every language at
+   * once through `localize("*")`.
+   */
+  @Localized({ fallbackLocale: LOCALIZED_TEXT_FALLBACK_LOCALE })
   @Field("string")
   declare name: string;
 

package/src/engine/formats.ts

@@ -0,0 +1,124 @@
+import type { VariableDefinition } from "../types";
+
+/**
+ * An amount in the minor unit of its currency (cents for `EUR`), like the
+ * DMS's composed-text `money` parameter: `{ value: 987420, currency: "EUR" }`
+ * reads "€9,874.20" in English, "9 874,20 €" in French.
+ */
+export interface MoneyValue {
+  value: number;
+  /** ISO 4217 code. An unknown code writes the amount as a plain number. */
+  currency: string;
+}
+
+/** How a send writes its typed values: its locale, and the paths typed `date`. */
+export interface ValueFormat {
+  locale: string;
+  datePaths: Set<string>;
+}
+
+const FALLBACK_LOCALE = "en";
+const DATE_STYLE: Intl.DateTimeFormatOptions = { dateStyle: "long" };
+const UTC_DATE_STYLE: Intl.DateTimeFormatOptions = {
+  ...DATE_STYLE,
+  timeZone: "UTC",
+};
+/** A calendar day: written as that day, whatever the server's time zone. */
+const ISO_DAY = /^\d{4}-\d{2}-\d{2}$/;
+/** A moment: written as its day in the server's time zone. */
+const ISO_DATE_TIME = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
+const DECIMAL_BASE = 10;
+const DATE_TYPE = "date";
+
+/** `locale` when the runtime can format for it, English otherwise. */
+export function formattingLocale(locale: string): string {
+  try {
+    return Intl.NumberFormat.supportedLocalesOf(locale)[0] ?? FALLBACK_LOCALE;
+  } catch {
+    return FALLBACK_LOCALE;
+  }
+}
+
+/** The paths a template declares `date`: their ISO strings are written as dates. */
+export function valueFormatOf(
+  locale: string,
+  variables: VariableDefinition[] = [],
+): ValueFormat {
+  return {
+    locale: formattingLocale(locale),
+    datePaths: new Set(
+      variables
+        .filter((variable) => variable.type === DATE_TYPE)
+        .map((variable) => variable.path),
+    ),
+  };
+}
+
+export function isMoneyValue(value: unknown): value is MoneyValue {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value as Partial<MoneyValue>;
+  return (
+    typeof candidate.value === "number" &&
+    Number.isFinite(candidate.value) &&
+    typeof candidate.currency === "string"
+  );
+}
+
+function formatMoney(money: MoneyValue, locale: string): string {
+  try {
+    const currency = new Intl.NumberFormat(locale, {
+      style: "currency",
+      currency: money.currency,
+    });
+    const digits = currency.resolvedOptions().maximumFractionDigits ?? 0;
+    return currency.format(money.value / DECIMAL_BASE ** digits);
+  } catch {
+    return new Intl.NumberFormat(locale).format(money.value);
+  }
+}
+
+function formatDate(
+  date: Date,
+  options: Intl.DateTimeFormatOptions,
+  locale: string,
+): string {
+  return new Intl.DateTimeFormat(locale, options).format(date);
+}
+
+function isoDateOptions(value: string): Intl.DateTimeFormatOptions | null {
+  if (ISO_DAY.test(value)) return UTC_DATE_STYLE;
+  if (ISO_DATE_TIME.test(value)) return DATE_STYLE;
+  return null;
+}
+
+/** An ISO string at a `date` path as the date it names; `null` otherwise. */
+function formatIsoDate(value: string, locale: string): string | null {
+  const options = isoDateOptions(value);
+  if (!options) return null;
+  const date = new Date(value);
+  return Number.isNaN(date.getTime())
+    ? null
+    : formatDate(date, options, locale);
+}
+
+/**
+ * A value as a recipient reads it. A money value and a `Date` format
+ * themselves in the send's locale wherever they appear; an ISO string is
+ * written as a date only at a path the template declares `date`; anything
+ * else, a string already formatted by the caller among them, as given.
+ */
+export function formatValue(
+  value: unknown,
+  path = "",
+  format?: ValueFormat,
+): string {
+  const locale = format?.locale ?? FALLBACK_LOCALE;
+  if (isMoneyValue(value)) return formatMoney(value, locale);
+  if (value instanceof Date)
+    return Number.isNaN(value.getTime())
+      ? String(value)
+      : formatDate(value, DATE_STYLE, locale);
+  if (typeof value === "string" && format?.datePaths.has(path))
+    return formatIsoDate(value, locale) ?? value;
+  return String(value);
+}

package/src/engine/index.ts

@@ -2,6 +2,7 @@ export * from "./changes";
 export * from "./conditions";
 export * from "./coverage";
 export * from "./fallback-html";
+export * from "./formats";
 export * from "./paths";
 export * from "./plain-text";
 export * from "./resolve";

package/src/engine/resolve.ts

@@ -15,6 +15,7 @@ import type {
 } from "../types";
 import { evaluateCondition } from "./conditions";
 import { safeUrl } from "./fallback-html";
+import { formatValue, type ValueFormat } from "./formats";
 import { getPath, isPresent } from "./paths";
 import { footerLinkPaths } from "./system-variables";
 import { type InterpolationMode, interpolate } from "./tokens";
@@ -26,6 +27,7 @@ interface ResolveState {
   mode: InterpolationMode;
   missing: Set<string>;
   hidden: string[];
+  format?: ValueFormat;
 }
 
 /** A blocked image source: the hero is left out rather than drawn broken. */
@@ -34,7 +36,7 @@ const BLOCKED_IMAGE = "";
 type BlockResolver = (block: Block, state: ResolveState) => ResolvedBlock[];
 
 function text(state: ResolveState, value: string): string {
-  const result = interpolate(value, state.data, state.mode);
+  const result = interpolate(value, state.data, state.mode, state.format);
   for (const path of result.missing) state.missing.add(path);
   return result.text;
 }
@@ -61,9 +63,10 @@ function systemUrl(
   return isPresent(value) ? safeUrl(String(value)) : "";
 }
 
-function cell(item: unknown, path: string): string {
+/** A list cell: a money value or a date in it is written for the locale. */
+function cell(item: unknown, path: string, state: ResolveState): string {
   const value = getPath(item, path);
-  return isPresent(value) ? String(value) : "";
+  return isPresent(value) ? formatValue(value, "", state.format) : "";
 }
 
 function listRows(block: ListBlock, state: ResolveState): ResolvedListRow[] {
@@ -73,8 +76,8 @@ function listRows(block: ListBlock, state: ResolveState): ResolvedListRow[] {
     return [];
   }
   return source.map((item) => ({
-    label: cell(item, block.labelPath),
-    value: cell(item, block.valuePath),
+    label: cell(item, block.labelPath, state),
+    value: cell(item, block.valuePath, state),
   }));
 }
 
@@ -191,14 +194,22 @@ const isUserPath = (path: string): boolean =>
 
 /**
  * Resolves `content` against `data`. A real send passes `send` so a missing
- * value leaves a blank; previews keep the token visible.
+ * value leaves a blank; previews keep the token visible. `format` writes the
+ * typed values (money, dates) for the e-mail's locale: see `valueFormatOf`.
  */
 export function resolveEmail(
   content: LocaleContent,
   data: Data,
   mode: InterpolationMode = "preview",
+  format?: ValueFormat,
 ): ResolvedEmail {
-  const state: ResolveState = { data, mode, missing: new Set(), hidden: [] };
+  const state: ResolveState = {
+    data,
+    mode,
+    missing: new Set(),
+    hidden: [],
+    format,
+  };
   const subject = text(state, content.subject);
   const preheader = text(state, content.preheader);
   const blocks = resolveBlocks(content.blocks, state);

package/src/engine/tokens.ts

@@ -1,3 +1,4 @@
+import { formatValue, type ValueFormat } from "./formats";
 import { getPath, isPresent } from "./paths";
 
 export const TOKEN_PATTERN = /\{\{\s*([A-Za-z0-9_.[\]]+)\s*\}\}/g;
@@ -25,14 +26,15 @@ export function extractTokens(text: string): string[] {
   return [...found];
 }
 
-function formatValue(value: unknown): string {
-  return value instanceof Date ? value.toISOString() : String(value);
-}
-
+/**
+ * Replaces each token of `text` with its value in `data`, typed values
+ * written for `format`'s locale (see {@link formatValue}).
+ */
 export function interpolate(
   text: string,
   data: Record<string, unknown>,
   mode: InterpolationMode = "preview",
+  format?: ValueFormat,
 ): InterpolationResult {
   const missing = new Set<string>();
   const output = text.replace(TOKEN_PATTERN, (token, path: string) => {
@@ -41,7 +43,7 @@ export function interpolate(
       missing.add(path);
       return MISSING_TOKEN[mode](token);
     }
-    return formatValue(value);
+    return formatValue(value, path, format);
   });
   return { text: output, missing: [...missing] };
 }

package/src/frontend-module.ts

@@ -0,0 +1,36 @@
+import path from "node:path";
+import type { AddFrontendModuleOptions } from "@antelopejs/interface-dms/page";
+import {
+  API_BASE_PATH,
+  FRONTEND_MODULE_NAME,
+  WEBHOOK_SECRET_HEADER,
+} from "./constants";
+
+/**
+ * The provider webhook (`/events/:provider/:tenantId`), served through the
+ * dashboard's public URL: the front proxy lets it through without an
+ * `Origin`, never sends it a session and relays the secret header, which the
+ * route checks itself.
+ */
+const PROVIDER_WEBHOOK_ENDPOINT = {
+  path: `${API_BASE_PATH}/events/*/*`,
+  methods: ["POST"],
+  headers: [WEBHOOK_SECRET_HEADER],
+};
+
+/**
+ * This module's frontend, from its configuration alone: the backend registers
+ * it with `AddFrontendModule`, and `@antelopejs/dms-frontend` calls this same
+ * function (declared as `dmsFrontend` in package.json) to build and start the
+ * frontend without a backend. It reads nothing but its arguments.
+ */
+export function frontendModule(): AddFrontendModuleOptions {
+  return {
+    name: FRONTEND_MODULE_NAME,
+    sourcePath: path.join(__dirname, "../frontend-vue"),
+    renderer: { name: "vue", version: "3" },
+    options: { dmsMailing: {} },
+    priority: 0,
+    publicEndpoints: [PROVIDER_WEBHOOK_ENDPOINT],
+  };
+}

package/src/hooks/tenant-export.ts

@@ -10,6 +10,7 @@ import {
 } from "@antelopejs/interface-dms/hooks";
 import { MODULE_ID } from "../constants";
 import {
+  type MailingTemplate,
   SettingsModel,
   SuppressionModel,
   TemplateModel,
@@ -98,6 +99,12 @@ async function loadPage<T extends object>(
     .filter((row): row is T => row !== undefined);
 }
 
+/** A template as exported: its name in every language. */
+const templateCodec: RowCodec<MailingTemplate> = {
+  fromDatabase: (row) =>
+    TemplateModel.fromDatabase(row)?.localize("*", ["name"]),
+};
+
 export function exportedCollections(tenantId: string): ExportedCollection[] {
   const templates = GetModel(TemplateModel, tenantId);
   const versions = GetModel(TemplateVersionModel, tenantId);
@@ -106,7 +113,7 @@ export function exportedCollections(tenantId: string): ExportedCollection[] {
     {
       entry: TEMPLATES_ENTRY,
       load: (offset, size) =>
-        loadPage(templates.table, TemplateModel, offset, size),
+        loadPage(templates.table, templateCodec, offset, size),
     },
     {
       entry: TEMPLATE_VERSIONS_ENTRY,