@antelopejs/dms-mailing 0.7.1 → 0.8.0

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/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");

package/src/services/events.ts

@@ -16,6 +16,7 @@ import { publishSendUpdated } from "../realtime";
 import type { SendEventType, SendStatus } from "../types";
 import { notifyProblems } from "./notify";
 import { suppressAddress, suppressionReasonOf } from "./suppressions";
+import { isObject, isText } from "../validation/guards";
 
 export interface SendCounters {
   status: SendStatus;
@@ -59,8 +60,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 +74,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 +99,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 +148,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 +167,10 @@ 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(isObject(storedDetails) ? storedDetails : undefined) === eventId
+    );
   }
   if (!event.at || stored.type !== event.type) return false;
   return (
@@ -223,7 +226,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

@@ -122,7 +122,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 +262,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(
@@ -161,11 +162,10 @@ const OUTCOME_SEVERITY: Record<SendStatus, number> = {
 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];
@@ -468,15 +468,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(
@@ -525,7 +525,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/starters.ts

@@ -32,16 +32,16 @@ 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) {
   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,
     };

package/src/services/templates.ts

@@ -180,13 +180,18 @@ interface FooterLabels {
   preferences: string;
 }
 
+const ENGLISH_FOOTER_LABELS: FooterLabels = {
+  unsubscribe: "Unsubscribe",
+  preferences: "Preferences",
+};
+
 /**
  * The one piece of content the module still writes for a new template. An
  * e-mail without an unsubscribe link is a legal problem, so a blank template
  * ships a footer — and nothing else: no invented subject, prose or address.
  */
 const FOOTER_LABELS: Record<string, FooterLabels> = {
-  en: { unsubscribe: "Unsubscribe", preferences: "Preferences" },
+  en: ENGLISH_FOOTER_LABELS,
   fr: { unsubscribe: "Se désinscrire", preferences: "Préférences" },
 };
 
@@ -194,7 +199,7 @@ const FOOTER_BLOCK_ID = "footer";
 
 /** A footer in `locale`: its legal line and the labels of its two links. */
 export function footerBlock(locale: string, text = ""): Block {
-  const labels = FOOTER_LABELS[locale] ?? (FOOTER_LABELS.en as FooterLabels);
+  const labels = FOOTER_LABELS[locale] ?? ENGLISH_FOOTER_LABELS;
   return {
     id: FOOTER_BLOCK_ID,
     type: "footer",
@@ -226,16 +231,13 @@ export function isStaleRevision(
   return revision !== undefined && revision !== template.draftRevision;
 }
 
-function draftWriteFields(
-  template: MailingTemplate,
-  author: string,
-): TemplateFields {
+function draftWriteFields(template: MailingTemplate, author: string) {
   return {
     draftRevision: template.draftRevision + 1,
     draftUpdatedAt: new Date(),
     draftUpdatedBy: author,
     updatedBy: author,
-  };
+  } satisfies TemplateFields;
 }
 
 /** Whether `draft` is exactly what customers and callers already have. */
@@ -271,7 +273,7 @@ export async function saveDraft(
     ...locales,
   });
   await refreshAttentionIfFlagged(tenantId, template, STALE_DRAFT);
-  return fields.draftRevision as number;
+  return fields.draftRevision;
 }
 
 export async function discardDraft(

package/src/validation/declarations.schema.ts

@@ -1,7 +1,7 @@
 import { LOCALIZED_TEXT_FALLBACK_LOCALE } from "@antelopejs/interface-dms-mailing";
 import { z } from "zod";
 import { MAX_NAME_LENGTH } from "../constants";
-import { SEND_EVENT_TYPES } from "../types";
+import { sendEventTypeSchema } from "./send-event-type.schema";
 import { categorySchema, settingsSchema } from "./settings.schema";
 import {
   slugSchema,
@@ -76,7 +76,7 @@ const recipientSchema = z.union([
 ]);
 
 const importedEventSchema = z.object({
-  type: z.enum(SEND_EVENT_TYPES as [string, ...string[]]),
+  type: sendEventTypeSchema,
   at: z.coerce.date(),
   details: z.record(z.unknown()).optional(),
 });

package/src/validation/guards.ts

@@ -0,0 +1,25 @@
+/** Whether `value` is a string. */
+export function isText(value: unknown): value is string {
+  return typeof value === "string";
+}
+
+/**
+ * Whether `value` is a JSON object as a parsed body holds one: an object,
+ * neither `null` nor an array. Its values are not checked.
+ */
+export function isJsonObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Whether `value` is an object, arrays included, and not `null`: reading any
+ * key of it yields a value of unknown type.
+ */
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+/** Whether `value` is a number. */
+export function isNumber(value: unknown): value is number {
+  return typeof value === "number";
+}

package/src/validation/send-event-type.schema.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+import { SEND_EVENT_TYPES } from "../types";
+
+const [FIRST_EVENT_TYPE, ...OTHER_EVENT_TYPES] = SEND_EVENT_TYPES;
+
+/** A send event's type: one of {@link SEND_EVENT_TYPES}. */
+export const sendEventTypeSchema = z.enum([
+  FIRST_EVENT_TYPE,
+  ...OTHER_EVENT_TYPES,
+]);

package/src/validation/settings.schema.ts

@@ -123,12 +123,18 @@ function moveIssues(
   kept: Set<string>,
 ): CategoryIssue[] {
   return entries.flatMap((entry, index) =>
-    isKept(entry) || kept.has(entry.moveTo as string)
+    entry.moveTo === undefined || kept.has(entry.moveTo)
       ? []
       : [{ message: UNKNOWN_MOVE_TARGET, path: [index, "moveTo"] }],
   );
 }
 
+/**
+ * Adds the issues of the category rows: blank labels and duplicates in each
+ * language, a removed marketing category, a move to a category that is not
+ * kept. Each issue is reported once per row and part, whichever language
+ * shows it first.
+ */
 function refineCategoryEntries(
   entries: CategoryEntry[],
   context: z.RefinementCtx,
@@ -147,7 +153,6 @@ function refineCategoryEntries(
     ...moveIssues(entriesIn(entries, LOCALIZED_TEXT_FALLBACK_LOCALE), kept),
   ]
     .filter((issue) => {
-      // One issue per row and part, whichever language shows it first.
       const id = JSON.stringify(issue);
       if (seen.has(id)) return false;
       seen.add(id);

package/src/validation/templates.schema.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { MAX_NAME_LENGTH, MAX_SLUG_LENGTH, SLUG_PATTERN } from "../constants";
+import type { Block } from "../types";
 
 const MIN_HEADING_SIZE = 12;
 const MAX_HEADING_SIZE = 48;
@@ -31,7 +32,7 @@ export const conditionSchema = z.object({
 const alignSchema = z.enum(["left", "center", "right"]);
 const base = { id: z.string().min(1), visibleIf: conditionSchema.nullable() };
 
-export const blockSchema: z.ZodType<unknown> = z.lazy(() =>
+export const blockSchema: z.ZodType<Block, z.ZodTypeDef, unknown> = z.lazy(() =>
   z.discriminatedUnion("type", [
     z.object({
       ...base,

package/frontend-vue/tests/i18n-editor.test.ts

@@ -1,50 +0,0 @@
-import { readFileSync, readdirSync } from 'node:fs'
-import { join } from 'node:path'
-import { describe, expect, it } from 'vitest'
-import en from '../i18n/locales/mailing-en-GB.json'
-
-const APP = join(__dirname, '..', 'app')
-const EDITOR_SOURCES = [
-	join(APP, 'components', 'Editor.vue'),
-	join(APP, 'composables', 'useEditorActions.ts'),
-	join(APP, 'composables', 'useEditorShortcuts.ts'),
-	...readdirSync(join(APP, 'components', 'editor')).map((file) =>
-		join(APP, 'components', 'editor', file),
-	),
-]
-const LITERAL_KEY =
-	/'(dms_mailing\.(?:editor|blocks|templates\.status)\.[a-z_.]+)'/g
-const PREFIX_CONSTANT = /const (\w*KEY) = '(dms_mailing[a-z_.]*)'/g
-const PREFIXED_KEY = /\$\{(\w*KEY)\}\.([a-z_.]+)`/g
-
-function keysUsedIn(source: string): string[] {
-	const prefixes = new Map(
-		[...source.matchAll(PREFIX_CONSTANT)].map((match) => [match[1], match[2]]),
-	)
-	const prefixValues = new Set(prefixes.values())
-	const literal = [...source.matchAll(LITERAL_KEY)]
-		.map((match) => match[1] as string)
-		.filter((key) => !prefixValues.has(key))
-	const prefixed = [...source.matchAll(PREFIXED_KEY)]
-		.filter((match) => prefixes.has(match[1]))
-		.map((match) => `${prefixes.get(match[1])}.${match[2]}`)
-	return [...literal, ...prefixed]
-}
-
-function keysOf(value: unknown, prefix = ''): string[] {
-	if (typeof value !== 'object' || value === null) return [prefix]
-	return Object.entries(value).flatMap(([key, child]) =>
-		keysOf(child, prefix ? `${prefix}.${key}` : key),
-	)
-}
-
-describe('editor locales', () => {
-	it('define every literal key the editor components use', () => {
-		const known = new Set(keysOf(en))
-		const used = EDITOR_SOURCES.flatMap((file) =>
-			keysUsedIn(readFileSync(file, 'utf8')),
-		)
-		expect(used.length).toBeGreaterThan(0)
-		expect(used.filter((key) => !known.has(key))).toEqual([])
-	})
-})