@antelopejs/dms-mailing 0.3.4 → 0.4.0

package/src/data/templates-table.ts

@@ -3,6 +3,7 @@ import {
   HTTPResult,
   type RequestContext,
 } from "@antelopejs/interface-api";
+import { assertValidation } from "@antelopejs/interface-api-util";
 import {
   DataController,
   type DataControllerCallback,
@@ -11,6 +12,8 @@ import {
 import {
   Access,
   AccessMode,
+  Filter,
+  type FilterFunction,
   Listable,
   Mandatory,
   ModelReference,
@@ -28,23 +31,61 @@ import {
   TableViewRoutes,
 } from "@antelopejs/interface-dms/base";
 import { DefaultDataTypes } from "@antelopejs/interface-dms/base/data-types/default-types";
+import { DefaultDisplays } from "@antelopejs/interface-dms/base/table-view";
 import { ReadonlyBehaviorType } from "@antelopejs/interface-dms/base/types";
-import { HTTP_CONFLICT, HTTP_NOT_FOUND, TABLES_BASE_PATH } from "../constants";
+import {
+  ARCHIVED_STATUS,
+  HTTP_BAD_REQUEST,
+  HTTP_CONFLICT,
+  HTTP_NOT_FOUND,
+  HTTP_UNPROCESSABLE,
+  MAX_NAME_LENGTH,
+  MAX_SLUG_LENGTH,
+  TABLES_BASE_PATH,
+} from "../constants";
 import { TemplateCategoryType } from "../data-types";
-import { MailingTemplate, TemplateModel } from "../db";
-import { getSettings } from "../services/settings";
-import { displayName, initializeTemplate } from "../services/templates";
+import { footerForCategory } from "../engine";
+import {
+  MailingTemplate,
+  SendModel,
+  TemplateModel,
+  TemplateVersionModel,
+} from "../db";
+import { findCategory, getSettings } from "../services/settings";
+import { findStarter, starterFields } from "../services/starters";
+import { refreshTemplateAttention } from "../services/template-attention";
+import {
+  blankContent,
+  blankFields,
+  contentFieldsOf,
+  displayName,
+  initializeTemplate,
+} from "../services/templates";
+import type { TemplateCategory } from "../types";
 
 import { createTemplateSchema } from "../validation/templates.schema";
 import { parseBody } from "./body";
+import { CategoryDisplay, LocaleChipsDisplay } from "./displays";
 
 const DUPLICATE_SLUG = "$dms_mailing.errors.duplicate_slug";
 const SLUG_IMMUTABLE = "$dms_mailing.errors.slug_immutable";
 const SOURCE_NOT_FOUND = "$dms_mailing.errors.template_not_found";
+const STARTER_NOT_FOUND = "$dms_mailing.errors.starter_not_found";
+const INVALID_TEMPLATE = "$dms_mailing.errors.invalid_template";
+const UNKNOWN_CATEGORY = "$dms_mailing.errors.unknown_category";
+const TEMPLATE_IN_USE = "$dms_mailing.errors.template_in_use";
+const TEMPLATE_WAS_SENT = "$dms_mailing.errors.template_was_sent";
+const MIN_NAME_LENGTH = 1;
 const CREATE_ONLY = { edit: ReadonlyBehaviorType.disabled };
-// Read-only columns render as empty dashes on the create form; the four fields
-// a template is actually created from are the only ones worth asking for.
-const NEVER_ON_CREATE = { new: ReadonlyBehaviorType.hidden };
+/**
+ * Read-only columns render as empty dashes on the create form and as raw
+ * internal values on the edit one: a template's name, slug and category are
+ * the only fields worth asking for.
+ */
+const NEVER_IN_FORMS = {
+  new: ReadonlyBehaviorType.hidden,
+  edit: ReadonlyBehaviorType.hidden,
+};
 
 const STATUS_ITEMS = ["draft", "live", "archived"].map((value) => ({
   value,
@@ -62,6 +103,85 @@ async function resolveSource(
   return source;
 }
 
+interface TemplateSeed {
+  sourceTemplateId?: string;
+  starterId?: string;
+  category?: string;
+}
+
+/** The content fields a creation starts from: a copy, a starter or a blank page. */
+async function seedFields(
+  tenantId: string,
+  seed: TemplateSeed,
+  fallbackLocale: string,
+): Promise<Partial<MailingTemplate>> {
+  const source = await resolveSource(tenantId, seed.sourceTemplateId);
+  if (source) return contentFieldsOf(source);
+  if (!seed.starterId) {
+    return blankFields(
+      footerForCategory(blankContent(fallbackLocale), seed.category),
+    );
+  }
+  const starter = findStarter(seed.starterId);
+  if (!starter) throw new HTTPResult(HTTP_NOT_FOUND, STARTER_NOT_FOUND);
+  return starterFields(starter, fallbackLocale);
+}
+
+const isBlank = (value: unknown) =>
+  value === undefined || value === null || value === "";
+
+/** A category is left empty or picked among the ones the settings declare. */
+function assertKnownCategory(
+  categories: TemplateCategory[],
+  category: unknown,
+): void {
+  if (isBlank(category)) return;
+  if (typeof category === "string" && findCategory(categories, category)) {
+    return;
+  }
+  throw new HTTPResult(HTTP_UNPROCESSABLE, UNKNOWN_CATEGORY);
+}
+
+const creationTime = (template: MailingTemplate) =>
+  new Date(template.createdAt).getTime();
+
+/**
+ * Nothing in the database keeps slugs unique, so two creations racing past
+ * the free-slug check both land: the earliest one stays, a later one is
+ * removed again and refused like any taken slug.
+ */
+async function assertFirstOfSlug(
+  model: TemplateModel,
+  slug: string,
+  templateId: string,
+): Promise<void> {
+  const [first] = (await model.getBy("slug", slug)).sort(
+    (left, right) =>
+      creationTime(left) - creationTime(right) ||
+      left._id.localeCompare(right._id),
+  );
+  if (!first || first._id === templateId) return;
+  await model.delete(templateId);
+  throw new HTTPResult(HTTP_CONFLICT, DUPLICATE_SLUG);
+}
+
+/** The creation's seed, and the body to store: slug and name trimmed. */
+function parseCreation(body: Buffer | string) {
+  const raw = parseBody(body);
+  const seed = assertValidation(
+    raw,
+    (value) => createTemplateSchema.parse(value),
+    () => INVALID_TEMPLATE,
+    HTTP_BAD_REQUEST,
+  );
+  const normalized = JSON.stringify({
+    ...raw,
+    slug: seed.slug,
+    name: seed.name,
+  });
+  return { seed, normalized };
+}
+
 function withSeeding(base: DataControllerCallback): DataControllerCallback {
   return {
     ...base,
@@ -72,82 +192,125 @@ function withSeeding(base: DataControllerCallback): DataControllerCallback {
       body: Buffer | string,
       ...rest: unknown[]
     ) {
-      const seed = createTemplateSchema.parse(parseBody(body));
+      const { seed, normalized } = parseCreation(body);
       const tenantId = getRequestTenantId(ctx);
-      const existing = await GetModel(TemplateModel, tenantId).getBySlug(
-        seed.slug,
-      );
-      if (existing) throw new HTTPResult(HTTP_CONFLICT, DUPLICATE_SLUG);
-      const source = await resolveSource(tenantId, seed.sourceTemplateId);
+      const model = GetModel(TemplateModel, tenantId);
+      if (await model.getBySlug(seed.slug)) {
+        throw new HTTPResult(HTTP_CONFLICT, DUPLICATE_SLUG);
+      }
+      const settings = await getSettings(tenantId);
+      assertKnownCategory(settings.categories, seed.category);
+      const fields = await seedFields(tenantId, seed, settings.fallbackLocale);
       const ids = (await base.func.call(
         this,
         ctx,
         params,
-        body,
+        normalized,
         ...rest,
       )) as string[];
+      const templateId = ids[0] as string;
+      await assertFirstOfSlug(model, seed.slug, templateId);
       const user = await authenticateTenantRequest(ctx);
-      const settings = await getSettings(tenantId);
-      await initializeTemplate(
-        tenantId,
-        ids[0] as string,
-        settings.fallbackLocale,
-        displayName(user),
-        source,
-      );
+      await initializeTemplate(tenantId, templateId, displayName(user), fields);
       return ids;
     },
   };
 }
 
-interface EditParams {
-  id: string;
+/** Whether a template was ever sent, a test included. */
+async function wasSent(sends: SendModel, slug: string): Promise<boolean> {
+  const count = await sends.table.getAll(slug, "templateSlug").count().run();
+  return count > 0;
 }
 
 /**
- * The body an edit may apply. Sends resolve templates by slug and nothing
- * enforces its uniqueness but the create checks, so a slug never changes once
- * set: a different one is refused, a missing one (which the data-api edit
- * would null) is kept.
+ * Why a template cannot go for good, `null` when it can: archived first
+ * (archiving explains what stops working), and never sent, since the send log
+ * renders past sends from it and a freed slug would inherit their figures.
  */
-async function withStoredSlug(
+async function deleteRefusal(
   tenantId: string,
-  templateId: string,
-  body: Buffer | string,
-): Promise<Buffer | string> {
-  const stored = await GetModel(TemplateModel, tenantId).get(templateId);
-  if (!stored) return body;
-  const edit = parseBody(body);
-  if (edit.slug !== undefined && edit.slug !== stored.slug) {
-    throw new HTTPResult(HTTP_CONFLICT, SLUG_IMMUTABLE);
+  template: MailingTemplate,
+): Promise<string | null> {
+  if (template.status !== ARCHIVED_STATUS) return TEMPLATE_IN_USE;
+  const isSent = await wasSent(GetModel(SendModel, tenantId), template.slug);
+  return isSent ? TEMPLATE_WAS_SENT : null;
+}
+
+/** The fields of an edit the guard checks. */
+interface TemplateEdit {
+  slug?: unknown;
+  category?: unknown;
+  name?: unknown;
+}
+
+/** The field a refused blank name is reported under. */
+const BLANK_NAME = { message: INVALID_TEMPLATE, field: "name" };
+
+/** What a guard does once the write it let through is done. */
+type AfterWrite = () => Promise<void>;
+
+/** Only an archived template never sent can go. */
+export async function assertDeletable(
+  tenantId: string,
+  model: TemplateModel,
+  ids: string[],
+): Promise<void> {
+  for (const id of ids) {
+    const template = await model.get(id);
+    const refusal = template && (await deleteRefusal(tenantId, template));
+    if (refusal) throw new HTTPResult(HTTP_CONFLICT, refusal);
   }
-  return JSON.stringify({ ...edit, slug: stored.slug });
 }
 
-function withFixedSlug(base: DataControllerCallback): DataControllerCallback {
-  return {
-    ...base,
-    func: async function (
-      this: unknown,
-      ctx: RequestContext,
-      params: EditParams,
-      body: Buffer | string,
-      ...rest: unknown[]
-    ) {
-      const guarded = await withStoredSlug(
-        getRequestTenantId(ctx),
-        params.id,
-        body,
-      );
-      return base.func.call(this, ctx, params, guarded, ...rest);
-    },
+/** A deleted template takes its published versions with it. */
+export function afterDelete(tenantId: string, ids: string[]): AfterWrite {
+  return async () => {
+    const versions = GetModel(TemplateVersionModel, tenantId).table;
+    await Promise.all(
+      ids.map((id) => versions.getAll(id, "templateId").delete().run()),
+    );
+    await refreshTemplateAttention(tenantId);
   };
 }
 
+/**
+ * Sends resolve templates by slug and nothing enforces its uniqueness but the
+ * create checks, so a slug never changes once set; a category must be one the
+ * settings declare, and a name holds more than spaces.
+ */
+export async function assertEditable(
+  tenantId: string,
+  body: TemplateEdit,
+  current: Pick<MailingTemplate, "slug">,
+): 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())
+    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. */
+export function afterEdit(
+  model: TemplateModel,
+  id: string,
+  name: unknown,
+): AfterWrite | undefined {
+  if (typeof name !== "string" || name === name.trim()) return undefined;
+  return async () => {
+    await model.update(id, { name: name.trim() });
+  };
+}
+
+/** The templates the attention refresh flagged. */
+const isFlagged: FilterFunction<Record<string, unknown>> = (_context, proxy) =>
+  proxy.default(false).eq(true);
+
 const templateRoutes = {
   ...TableViewRoutes.All,
   new: withSeeding(TableViewRoutes.New),
-  edit: withFixedSlug(TableViewRoutes.Edit),
 };
 
 @RegisterDataController()
@@ -160,6 +323,9 @@ export class TemplatesTableAPI extends DataController(
   @TenantScopedModel(TemplateModel)
   declare model: TemplateModel;
 
+  @TenantScopedModel(SendModel)
+  declare sends: SendModel;
+
   @Select()
   @Listable()
   @Exported()
@@ -171,11 +337,14 @@ export class TemplatesTableAPI extends DataController(
   @Sortable()
   @Exported()
   @Searchable()
-  @Mandatory("new")
+  @Mandatory("new", "edit")
   @Access(AccessMode.ReadWrite)
   @Column({
     name: "$dms_mailing.templates.cols.name",
-    type: new DefaultDataTypes.StringType({}),
+    type: new DefaultDataTypes.StringType({
+      minLength: MIN_NAME_LENGTH,
+      maxLength: MAX_NAME_LENGTH,
+    }),
   })
   declare name: string;
 
@@ -188,8 +357,9 @@ export class TemplatesTableAPI extends DataController(
   @Access(AccessMode.ReadWrite)
   @Column({
     name: "$dms_mailing.templates.cols.slug",
-    type: new DefaultDataTypes.StringType({}),
+    type: new DefaultDataTypes.StringType({ maxLength: MAX_SLUG_LENGTH }),
     readonlyBehavior: CREATE_ONLY,
+    display: new DefaultDisplays.MonoDisplay({ copy: true }),
   })
   declare slug: string;
 
@@ -200,6 +370,7 @@ export class TemplatesTableAPI extends DataController(
     name: "$dms_mailing.templates.cols.category",
     type: new TemplateCategoryType(),
     filterable: true,
+    display: new CategoryDisplay({}),
   })
   declare category: string;
 
@@ -211,7 +382,10 @@ export class TemplatesTableAPI extends DataController(
     name: "$dms_mailing.templates.cols.status",
     type: new DefaultDataTypes.SelectType({ items: STATUS_ITEMS }),
     filterable: true,
-    readonlyBehavior: NEVER_ON_CREATE,
+    readonlyBehavior: NEVER_IN_FORMS,
+    display: new DefaultDisplays.StatusPillDisplay({
+      tones: { live: "success", draft: "neutral", archived: "warning" },
+    }),
   })
   declare status: string;
 
@@ -222,7 +396,12 @@ export class TemplatesTableAPI extends DataController(
   @Column({
     name: "$dms_mailing.templates.cols.updatedAt",
     type: new DefaultDataTypes.DateType({}),
-    readonlyBehavior: NEVER_ON_CREATE,
+    readonlyBehavior: NEVER_IN_FORMS,
+    display: new DefaultDisplays.RelativeDateDisplay({
+      style: "day",
+      byField: "updatedBy",
+      byLabel: "$dms_mailing.templates.cols.updated_by",
+    }),
   })
   declare updatedAt: Date;
 
@@ -232,7 +411,8 @@ export class TemplatesTableAPI extends DataController(
   @Column({
     name: "$dms_mailing.templates.cols.locales",
     type: new DefaultDataTypes.StringType({}),
-    readonlyBehavior: NEVER_ON_CREATE,
+    readonlyBehavior: NEVER_IN_FORMS,
+    display: new LocaleChipsDisplay({}),
   })
   declare locales: string;
 
@@ -242,7 +422,59 @@ export class TemplatesTableAPI extends DataController(
   @Column({
     name: "$dms_mailing.templates.cols.updatedBy",
     type: new DefaultDataTypes.StringType({}),
-    readonlyBehavior: NEVER_ON_CREATE,
+    readonlyBehavior: NEVER_IN_FORMS,
   })
   declare updatedBy: string;
+
+  @Listable()
+  @Access(AccessMode.ReadOnly)
+  @Column({
+    name: "$dms_mailing.templates.cols.publishedVersion",
+    type: new DefaultDataTypes.NumberType({}),
+    readonlyBehavior: NEVER_IN_FORMS,
+    isVisible: false,
+  })
+  declare publishedVersion: number;
+
+  @Listable()
+  @Access(AccessMode.ReadOnly)
+  @Column({
+    name: "$dms_mailing.templates.cols.isDraftPending",
+    type: new DefaultDataTypes.BooleanType({}),
+    readonlyBehavior: NEVER_IN_FORMS,
+    isVisible: false,
+  })
+  declare isDraftPending: boolean;
+
+  @Listable()
+  @Access(AccessMode.ReadOnly)
+  @Column({
+    name: "$dms_mailing.templates.cols.publishedAt",
+    type: new DefaultDataTypes.DateType({}),
+    readonlyBehavior: NEVER_IN_FORMS,
+    isVisible: false,
+  })
+  declare publishedAt: Date;
+
+  /** Why the template needs a look (comma-separated), for the gallery cards. */
+  @Listable()
+  @Access(AccessMode.ReadOnly)
+  declare attention: string;
+
+  /** What the "Needs attention" tab filters on, whatever value it names. */
+  @Filter(isFlagged)
+  @Access(AccessMode.ReadOnly)
+  declare needsAttention: boolean;
+
+  /**
+   * Whether an archived template was ever sent: the gallery then offers no
+   * Delete, which the route would refuse. Read for archived rows only, the
+   * only ones Delete is offered on.
+   */
+  @Listable(["slug", "status"])
+  @Access(AccessMode.ReadOnly)
+  get hasSends(): Promise<boolean> | boolean {
+    if (this.status !== ARCHIVED_STATUS || !this.sends) return false;
+    return wasSent(this.sends, this.slug);
+  }
 }

package/src/data-types/categories-type.ts

@@ -4,12 +4,11 @@ import {
   RegisterDataType,
 } from "@antelopejs/interface-dms/base/data-types";
 import { TEMPLATE_CATEGORIES_TYPE_ID } from "../constants";
-import { CATEGORIES_SCHEMA } from "../services/categories";
+import { categoriesSchema } from "../validation/settings.schema";
 
 /**
  * The tenant's template categories as a settings field — a repeatable list of
- * {id, label, icon} that no built-in DataType models: the input is ours, and
- * the validation accepts the array or the JSON string a form field stores.
+ * {id, label, icon} that no built-in DataType models: the input is ours.
  */
 @RegisterDataType(TEMPLATE_CATEGORIES_TYPE_ID)
 export class TemplateCategoriesType extends DataType {
@@ -18,12 +17,12 @@ export class TemplateCategoriesType extends DataType {
   }
 
   protected defaultInputComponent() {
-    return CustomComponent("DmsMailingCategoriesInput")
+    return CustomComponent("MailingCategoriesInput")
       .options(this.options)
       .serializeSync();
   }
 
   getValidation() {
-    return CATEGORIES_SCHEMA;
+    return categoriesSchema;
   }
 }

package/src/data-types/category-type.ts

@@ -33,7 +33,7 @@ export class TemplateCategoryType extends DataType {
   }
 
   protected defaultInputComponent() {
-    return CustomComponent("DmsMailingCategoryInput")
+    return CustomComponent("MailingCategoryInput")
       .options(this.options)
       .serializeSync();
   }

package/src/db/models/index.ts

@@ -1,4 +1,7 @@
 export * from "./send-events.model";
 export * from "./sends.model";
 export * from "./settings.model";
+export * from "./suppressions.model";
+export * from "./template-versions.model";
 export * from "./templates.model";
+export * from "./webhook-status.model";

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

@@ -4,6 +4,7 @@ import type {
   AtomicMutationOutcome,
   ValueProxy,
 } from "@antelopejs/interface-database";
+import { isResolvedStage, stageOf } from "../../types";
 import { MAILING_SENDS_TABLE_NAME, MailingSend } from "../tables";
 
 const FIRST_ROW_OFFSET = 0;
@@ -14,14 +15,33 @@ type NewSend = Omit<
   "_id" | "createdAt" | "revision" | "isRetiring" | "lastActivityAt"
 >;
 
+const MAX_MUTATION_ATTEMPTS = 5;
+
 /** A send as the metrics read it: everything but the rendered variables. */
 export type SendSummary = Omit<MailingSend, "json_variables">;
 
 type SendActivity = Pick<
   MailingSend,
-  "status" | "opens" | "clicks" | "lastEventAt" | "provider"
+  | "status"
+  | "opens"
+  | "clicks"
+  | "lastEventAt"
+  | "provider"
+  | "error"
+  | "isSoftBounce"
 >;
 
+/** Who sent a problem again, and the send that did. */
+export interface SendReplay {
+  replayedBy: string;
+  resolvedBy: string;
+}
+
+type SendPatch = Partial<MailingSend>;
+
+/** The change to make to a send's latest row, `null` to leave it alone. */
+type PatchOf = (send: MailingSend) => SendPatch | null;
+
 function canRetire(row: ValueProxy<MailingSend>, limit: Date) {
   return row
     .key("createdAt")
@@ -134,6 +154,9 @@ export class SendModel extends BasicDataModel(
     const patch = Object.fromEntries(
       Object.entries({
         ...changes,
+        stage: changes.status
+          ? stageOf(changes.status, isResolvedStage(send.stage))
+          : undefined,
         lastActivityAt: new Date(),
       }).filter(([, value]) => value !== undefined),
     );
@@ -148,4 +171,82 @@ export class SendModel extends BasicDataModel(
       .run();
     return wasApplied(outcome);
   }
+
+  /**
+   * Takes a problem out of the Problems tab before it is sent again, so a
+   * second "send the failures again" skips it. `false` when it was already
+   * dealt with, or is gone.
+   */
+  claimResolution(sendId: string, resolvedBy: string): Promise<boolean> {
+    return this.mutateLatest(sendId, (send) =>
+      isResolvedStage(send.stage)
+        ? null
+        : {
+            resolvedAt: new Date(),
+            resolvedBy,
+            stage: stageOf(send.status, true),
+          },
+    );
+  }
+
+  /** Puts a claimed problem back when sending it again could not start. */
+  releaseResolution(sendId: string): Promise<boolean> {
+    return this.mutateLatest(sendId, (send) => ({
+      stage: stageOf(send.status),
+    }));
+  }
+
+  /** Links a send to the one that repeated it; a problem is then resolved. */
+  markReplayed(sendId: string, replay: SendReplay): Promise<boolean> {
+    return this.mutateLatest(sendId, (send) => ({
+      ...replay,
+      resolvedAt: new Date(),
+      stage: stageOf(send.status, true),
+    }));
+  }
+
+  /** Links a send again to the send it repeats. */
+  linkReplayOf(sendId: string, originalId: string): Promise<boolean> {
+    return this.mutateLatest(sendId, () => ({ replayOf: originalId }));
+  }
+
+  private async mutateLatest(
+    sendId: string,
+    patchOf: PatchOf,
+  ): Promise<boolean> {
+    for (let attempt = 0; attempt < MAX_MUTATION_ATTEMPTS; attempt++) {
+      const send = await this.getSnapshot(sendId);
+      if (!send || send.isRetiring) return false;
+      const patch = patchOf(send);
+      if (!patch) return false;
+      const outcome = await this.table
+        .atomicMutation(sendId, {
+          type: "update",
+          revisionField: "revision",
+          expectedRevision: send.revision,
+          nextRevision: randomUUID(),
+          patch,
+        })
+        .run();
+      if (wasApplied(outcome)) return true;
+    }
+    return false;
+  }
+
+  /** Sends of a template since `from`, without the rendered variables. */
+  listForTemplate(templateSlug: string, from: Date): Promise<SendSummary[]> {
+    return this.table
+      .getAll(templateSlug, "templateSlug")
+      .filter((row) => row.key("createdAt").ge(from))
+      .without("json_variables")
+      .run() as Promise<SendSummary[]>;
+  }
+
+  /** How many sends the retention would delete with this cutoff. */
+  countOlderThan(limit: Date): Promise<number> {
+    return this.table
+      .filter((row) => canRetire(row, limit))
+      .count()
+      .run();
+  }
 }

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

@@ -1,18 +1,8 @@
 import { BasicDataModel } from "@antelopejs/interface-database-decorators";
 import { MAILING_SETTINGS_TABLE_NAME, MailingSettings } from "../tables";
 
+/** The tenant's settings: a single row, keyed by the tenant id. */
 export class SettingsModel extends BasicDataModel(
   MailingSettings,
   MAILING_SETTINGS_TABLE_NAME,
-) {
-  /**
-   * The tenant's settings row, keyed by the tenant id. Rows written before the
-   * key existed carry a random id and are still found by a scan.
-   */
-  async getSingleton(tenantId: string): Promise<MailingSettings | undefined> {
-    const keyed = await this.get(tenantId);
-    if (keyed) return keyed;
-    const rows = await this.getAll();
-    return rows[0];
-  }
-}
+) {}