@antelopejs/dms-mailing 0.9.0 → 0.9.2

package/src/services/template-attention.ts

@@ -5,13 +5,13 @@ import {
   type TemplateAttentionFields,
   TemplateModel,
 } from "../db";
-import { BUSINESS_AUDIENCE, type TemplateAttentionReason } from "../types";
+import type { TemplateAttentionReason } from "../types";
 import {
   knownLocalesOf,
   type TemplateAttentionContext,
   templateAttentionReasons,
 } from "./attention";
-import { forAudience, statsWindowStart } from "./metrics";
+import { statsWindowStart } from "./metrics";
 
 /** How the stored `attention` field separates its reasons. */
 const REASON_SEPARATOR = ",";
@@ -31,14 +31,13 @@ async function attentionContext(
   templates: MailingTemplate[],
 ): Promise<TemplateAttentionContext> {
   const now = Date.now();
-  const sends = await GetModel(SendModel, tenantId).listBetween(
+  const slugs = await GetModel(SendModel, tenantId).listSentSlugs(
     statsWindowStart(now),
     new Date(now),
   );
-  const real = forAudience(sends, BUSINESS_AUDIENCE);
   return {
     now,
-    sentSlugs: new Set(real.map((send) => send.templateSlug)),
+    sentSlugs: new Set(slugs),
     knownLocales: knownLocalesOf(templates),
   };
 }

package/src/services/webhook-secret-declaration.ts

@@ -0,0 +1,47 @@
+import type {
+  DeclareWebhookSecretResult,
+  WebhookSecretDeclaration,
+  WebhookSecretOutcome,
+} from "@antelopejs/interface-dms-mailing";
+import type { MailingSettingsValues } from "../types";
+import { webhookSecretDeclarationSchema } from "../validation/declarations.schema";
+import { parseDeclared } from "./declaration-error";
+import { webhookSecretMatches } from "./events";
+import { getSettings, saveWebhookSecret } from "./settings";
+
+const SET: WebhookSecretOutcome = "set";
+
+/**
+ * What declaring `secret` does to the stored one: nothing when it is already
+ * stored, nothing when the workspace owner set or rotated it and the caller
+ * did not ask to replace it, else a write.
+ */
+export function webhookSecretOutcome(
+  stored: Pick<MailingSettingsValues, "webhookSecret" | "webhookSecretSource">,
+  secret: string,
+  replaceRotated: boolean,
+): WebhookSecretOutcome {
+  if (webhookSecretMatches(secret, stored.webhookSecret)) return "unchanged";
+  if (stored.webhookSecretSource === "operator" && !replaceRotated)
+    return "kept";
+  return SET;
+}
+
+/**
+ * Sets the workspace's webhook secret a project ships as code. The secret is
+ * never returned, and a refusal names the rule it broke, never the value.
+ */
+export async function declareWebhookSecret(
+  input: WebhookSecretDeclaration,
+): Promise<DeclareWebhookSecretResult> {
+  const { tenantId, secret, replaceRotated } = parseDeclared(
+    webhookSecretDeclarationSchema,
+    input,
+    "invalid_webhook_secret",
+    "webhook secret declaration",
+  );
+  const stored = await getSettings(tenantId);
+  const outcome = webhookSecretOutcome(stored, secret, replaceRotated);
+  if (outcome === SET) await saveWebhookSecret(tenantId, secret, "declared");
+  return { outcome };
+}

package/src/services/webhook-status.ts

@@ -144,15 +144,19 @@ export async function readWebhookStatus(
   );
 }
 
+function isWebhookRefusal(value: unknown): value is WebhookRefusal {
+  return isText(value) && Object.hasOwn(WEBHOOK_REFUSAL_MESSAGES, value);
+}
+
+/** The webhook's own refusal reason in a response, not one another endpoint gives. */
 async function refusalOf(
   response: Response,
 ): Promise<WebhookRefusal | undefined> {
   try {
-    // SAFETY: Response.json() answers any, and the URL under test is this module's own webhook route, which refuses
-    // with refusalBody(reason); another endpoint can answer any JSON, which is read the same way, and a non-object
-    // reads as no refusal (only null throws, into the catch below).
-    const body = (await response.json()) as Partial<WebhookRefusalBody>;
-    return body.reason;
+    const body: unknown = await response.json();
+    return isObject(body) && isWebhookRefusal(body.reason)
+      ? body.reason
+      : undefined;
   } catch {
     return undefined;
   }

package/src/types/settings.ts

@@ -14,6 +14,19 @@ export interface CategoryInLocale {
   icon: string;
 }
 
+/**
+ * Who set the webhook secret: the module drew it (`generated`), a project
+ * declared it (`declared`), or the workspace owner set or rotated it in the
+ * settings (`operator`). A declaration replaces only the first two.
+ */
+export const WEBHOOK_SECRET_SOURCES = [
+  "generated",
+  "declared",
+  "operator",
+] as const;
+
+export type WebhookSecretSource = (typeof WEBHOOK_SECRET_SOURCES)[number];
+
 export interface MailingSettingsValues {
   fallbackLocale: string;
   logRetentionDays: number;
@@ -22,6 +35,7 @@ export interface MailingSettingsValues {
   senderEmail: string;
   replyTo: string;
   webhookSecret: string;
+  webhookSecretSource: WebhookSecretSource;
   categories: TemplateCategory[];
 }
 

package/src/validation/declarations.schema.ts

@@ -68,6 +68,13 @@ export const senderDeclarationSchema = z.object({
 
 export type ParsedSenderDeclaration = z.infer<typeof senderDeclarationSchema>;
 
+/** A webhook secret declared from code: the settings form's rule. */
+export const webhookSecretDeclarationSchema = z.object({
+  tenantId: tenantIdSchema,
+  secret: settingsSchema.shape.webhookSecret,
+  replaceRotated: z.boolean().default(false),
+});
+
 const recipientSchema = z.union([
   z.string().trim().email(),
   z.object({