@antelopejs/dms-mailing 0.4.1 → 0.5.1

package/src/db/models/index.ts

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

package/src/db/models/template-slugs.model.ts

@@ -0,0 +1,61 @@
+import { createHash } from "node:crypto";
+import { BasicDataModel } from "@antelopejs/interface-database-decorators";
+import {
+  MAILING_TEMPLATE_SLUGS_TABLE_NAME,
+  MailingTemplateSlug,
+} from "../tables";
+
+const ID_LENGTH = 32;
+
+/**
+ * The id of a slug's claim, the same whoever creates the template. The tenant
+ * is part of it: a driver may keep every tenant's rows in one collection,
+ * where a key made of the slug alone would collide across tenants.
+ */
+export function templateSlugIdOf(tenantId: string, slug: string): string {
+  return createHash("sha256")
+    .update(`${tenantId}\n${slug}`)
+    .digest("hex")
+    .slice(0, ID_LENGTH);
+}
+
+export class TemplateSlugModel extends BasicDataModel(
+  MailingTemplateSlug,
+  MAILING_TEMPLATE_SLUGS_TABLE_NAME,
+) {
+  /**
+   * Inserts the claim; false when the key is taken. Probed by state rather
+   * than by error, since the database interface exposes no typed conflict
+   * error: a claim present after a failed insert is the lost race.
+   */
+  async insertClaim(
+    id: string,
+    slug: string,
+    templateId: string,
+  ): Promise<boolean> {
+    try {
+      await this.insert({ _id: id, slug, templateId });
+      return true;
+    } catch (error) {
+      if (await this.get(id)) return false;
+      throw error;
+    }
+  }
+
+  /** Drops the claim if `templateId` still holds it, never a newer one. */
+  async dropClaimOf(id: string, templateId: string): Promise<void> {
+    await this.table
+      .atomicMutation(id, {
+        type: "deleteIfEqual",
+        field: "templateId",
+        expectedValue: templateId,
+      })
+      .run();
+  }
+
+  /** Frees the slugs the templates held. */
+  async releaseTemplates(templateIds: string[]): Promise<void> {
+    if (!templateIds.length) return;
+    await this.table.getAll(templateIds, "templateId").delete().run();
+  }
+}

package/src/db/tables/index.ts

@@ -2,6 +2,7 @@ export * from "./send-events.table";
 export * from "./sends.table";
 export * from "./settings.table";
 export * from "./suppressions.table";
+export * from "./template-slugs.table";
 export * from "./template-versions.table";
 export * from "./templates.table";
 export * from "./webhook-status.table";

package/src/db/tables/template-slugs.table.ts

@@ -0,0 +1,29 @@
+import {
+  Field,
+  Index,
+  RegisterTable,
+  Table,
+} from "@antelopejs/interface-database-decorators";
+import { TENANT_SCHEMA_NAME } from "@antelopejs/interface-dms/constants";
+
+export const MAILING_TEMPLATE_SLUGS_TABLE_NAME = "mailing_template_slugs";
+
+/**
+ * The template a slug belongs to. Its id derives from the tenant and the
+ * slug, so the primary key is what keeps a slug to one template: the database
+ * interface declares no unique secondary index, and two creations racing
+ * past the free-slug check both insert their template, but only one claim.
+ */
+@RegisterTable(MAILING_TEMPLATE_SLUGS_TABLE_NAME, TENANT_SCHEMA_NAME)
+export class MailingTemplateSlug extends Table {
+  @Field("string")
+  declare _id: string;
+
+  @Field("string")
+  declare slug: string;
+
+  /** The template holding the slug; a deleted one leaves the claim free. */
+  @Index()
+  @Field("string")
+  declare templateId: string;
+}

package/src/routes/templates.ts

@@ -37,6 +37,7 @@ import {
   type TemplateStats,
 } from "../services/template-stats";
 import {
+  assertSlugClaimed,
   contentFieldsOf,
   contentOfVersion,
   discardDraft,
@@ -536,6 +537,7 @@ export class TemplatesController extends Controller(
       ...contentFieldsOf(source),
       updatedBy: this.author,
     });
+    await assertSlugClaimed(this.tenantId, slug, copyId as string);
     await refreshTemplateAttention(this.tenantId);
     return { id: copyId };
   }

package/src/services/templates.ts

@@ -2,6 +2,7 @@ import { HTTPResult } from "@antelopejs/interface-api";
 import { GetModel } from "@antelopejs/interface-database-decorators";
 import {
   DEFAULT_FALLBACK_LOCALE,
+  HTTP_CONFLICT,
   HTTP_NOT_FOUND,
   LOCALE_LIST_SEPARATOR,
 } from "../constants";
@@ -9,7 +10,9 @@ import {
   type MailingTemplate,
   type MailingTemplateVersion,
   TemplateModel,
+  TemplateSlugModel,
   TemplateVersionModel,
+  templateSlugIdOf,
 } from "../db";
 import { diffContents, diffVariables, type TemplateChange } from "../engine";
 import {
@@ -39,6 +42,7 @@ const NEVER_PUBLISHED = 0;
 const STALE_DRAFT: TemplateAttentionReason = "stale_draft";
 const VERSION_NOT_FOUND = "$dms_mailing.errors.version_not_found";
 const TEMPLATE_NOT_FOUND = "$dms_mailing.errors.template_not_found";
+const DUPLICATE_SLUG = "$dms_mailing.errors.duplicate_slug";
 
 /** The template `id` names; 404 when there is none. */
 export async function requireTemplate(
@@ -50,6 +54,51 @@ export async function requireTemplate(
   return template;
 }
 
+/**
+ * Gives `slug` to the template just inserted; false when another template
+ * holds it. A claim whose template is gone (deleted before its claim was
+ * freed) is taken over, through the same insert that settles a race.
+ */
+async function claimTemplateSlug(
+  tenantId: string,
+  slug: string,
+  templateId: string,
+): Promise<boolean> {
+  const claims = GetModel(TemplateSlugModel, tenantId);
+  const id = templateSlugIdOf(tenantId, slug);
+  if (await claims.insertClaim(id, slug, templateId)) return true;
+  const holder = await claims.get(id);
+  if (holder) {
+    const templates = GetModel(TemplateModel, tenantId);
+    if (await templates.get(holder.templateId)) return false;
+    await claims.dropClaimOf(id, holder.templateId);
+  }
+  return claims.insertClaim(id, slug, templateId);
+}
+
+/**
+ * Keeps the template just inserted if it got its slug, or removes it again
+ * and refuses it like any taken slug: two creations racing past the free-slug
+ * check both insert, and only the claim's primary key tells them apart.
+ */
+export async function assertSlugClaimed(
+  tenantId: string,
+  slug: string,
+  templateId: string,
+): Promise<void> {
+  if (await claimTemplateSlug(tenantId, slug, templateId)) return;
+  await GetModel(TemplateModel, tenantId).delete(templateId);
+  throw new HTTPResult(HTTP_CONFLICT, DUPLICATE_SLUG);
+}
+
+/** Frees the slugs of deleted templates for new ones. */
+export async function releaseTemplateSlugs(
+  tenantId: string,
+  templateIds: string[],
+): Promise<void> {
+  await GetModel(TemplateSlugModel, tenantId).releaseTemplates(templateIds);
+}
+
 /** The content customers receive: the last published version. */
 export function parseContent(template: MailingTemplate): TemplateContent {
   return JSON.parse(template.json_content || EMPTY_CONTENT) as TemplateContent;