mailery 0.16.6 → 0.16.7

package/dist/{null-CDlseQxO.d.cts → null-oKPS74Gr.d.cts}

@@ -316,6 +316,23 @@ declare const unsubscribeInputSchema: z.ZodObject<{
     notes: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type UnsubscribeInput = z.infer<typeof unsubscribeInputSchema>;
+/**
+ * An explicit opt-in from someone who previously unsubscribed. Clears only the
+ * suppression an unsubscribe wrote (`reason: 'unsubscribed'`) — a bounce or
+ * complaint row is deliverability, not preference, and survives.
+ */
+declare const resubscribeInputSchema: z.ZodObject<{
+    externalId: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        marketing: "marketing";
+    }>>;
+    source: z.ZodString;
+    consentTimestamp: z.ZodOptional<z.ZodDate>;
+    consentIp: z.ZodOptional<z.ZodString>;
+    consentUserAgent: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ResubscribeInput = z.input<typeof resubscribeInputSchema>;
 declare const suppressInputSchema: z.ZodObject<{
     email: z.ZodString;
     scope: z.ZodEnum<{
@@ -727,6 +744,14 @@ interface MailerConfig {
      * Domains are case-insensitive. If unset, no enforcement happens.
      */
     senderDomains?: SenderDomainRegistry;
+    /**
+     * Hosts the linter treats as your own for the `offdomain_links` warning,
+     * on top of the From domain and `publicUrl`'s host. Set it when the product
+     * lives on a different domain than the sending identity (`app.example.com`
+     * mailed from `hello@example-mail.com`), so a body that links to the
+     * product is not reported as pointing away from the sender.
+     */
+    linkDomains?: string[];
     requireDoubleOptIn?: boolean;
     unsubscribeTokenLifetimeDays?: number;
     transactionalRespectUnsubscribe?: boolean;
@@ -1570,6 +1595,24 @@ declare class Mailer {
     fire(eventName: string, externalId: string, properties?: Record<string, unknown>, dedupeKey?: string): Promise<void>;
     fireFromSession(session: ClientSession, eventName: string, externalId: string, properties?: Record<string, unknown>, dedupeKey?: string): Promise<void>;
     upsertSubscription(input: UpsertSubscriptionInput): Promise<void>;
+    /**
+     * An explicit opt-in from a contact who unsubscribed before.
+     *
+     * `upsertSubscription` alone is not enough: an unsubscribe also writes a
+     * `mailer_suppressions` row, and the suppression check runs at enqueue
+     * time regardless of subscription status — so a contact re-subscribed
+     * through `upsertSubscription` reads as subscribed while every send comes
+     * back `suppressed`. This clears the opt-out rows (only those: a bounce or
+     * complaint is not the contact's to reverse), then upserts the subscription
+     * through the normal path, double opt-in included.
+     *
+     * Deliberately a separate method rather than a side effect of
+     * `upsertSubscription`, so a backfill or a model hook that re-upserts every
+     * account cannot silently resurrect addresses that opted out.
+     */
+    resubscribe(input: ResubscribeInput): Promise<{
+        removedSuppressions: number;
+    }>;
     /**
      * The writes live in `server/unsubscribe.ts` so the pending-unsubscribe
      * drain (INVARIANT 8) replays a journaled opt-out through exactly this path

package/dist/{null-CDlseQxO.d.ts → null-oKPS74Gr.d.ts}

@@ -316,6 +316,23 @@ declare const unsubscribeInputSchema: z.ZodObject<{
     notes: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type UnsubscribeInput = z.infer<typeof unsubscribeInputSchema>;
+/**
+ * An explicit opt-in from someone who previously unsubscribed. Clears only the
+ * suppression an unsubscribe wrote (`reason: 'unsubscribed'`) — a bounce or
+ * complaint row is deliverability, not preference, and survives.
+ */
+declare const resubscribeInputSchema: z.ZodObject<{
+    externalId: z.ZodString;
+    scope: z.ZodDefault<z.ZodEnum<{
+        all: "all";
+        marketing: "marketing";
+    }>>;
+    source: z.ZodString;
+    consentTimestamp: z.ZodOptional<z.ZodDate>;
+    consentIp: z.ZodOptional<z.ZodString>;
+    consentUserAgent: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ResubscribeInput = z.input<typeof resubscribeInputSchema>;
 declare const suppressInputSchema: z.ZodObject<{
     email: z.ZodString;
     scope: z.ZodEnum<{
@@ -727,6 +744,14 @@ interface MailerConfig {
      * Domains are case-insensitive. If unset, no enforcement happens.
      */
     senderDomains?: SenderDomainRegistry;
+    /**
+     * Hosts the linter treats as your own for the `offdomain_links` warning,
+     * on top of the From domain and `publicUrl`'s host. Set it when the product
+     * lives on a different domain than the sending identity (`app.example.com`
+     * mailed from `hello@example-mail.com`), so a body that links to the
+     * product is not reported as pointing away from the sender.
+     */
+    linkDomains?: string[];
     requireDoubleOptIn?: boolean;
     unsubscribeTokenLifetimeDays?: number;
     transactionalRespectUnsubscribe?: boolean;
@@ -1570,6 +1595,24 @@ declare class Mailer {
     fire(eventName: string, externalId: string, properties?: Record<string, unknown>, dedupeKey?: string): Promise<void>;
     fireFromSession(session: ClientSession, eventName: string, externalId: string, properties?: Record<string, unknown>, dedupeKey?: string): Promise<void>;
     upsertSubscription(input: UpsertSubscriptionInput): Promise<void>;
+    /**
+     * An explicit opt-in from a contact who unsubscribed before.
+     *
+     * `upsertSubscription` alone is not enough: an unsubscribe also writes a
+     * `mailer_suppressions` row, and the suppression check runs at enqueue
+     * time regardless of subscription status — so a contact re-subscribed
+     * through `upsertSubscription` reads as subscribed while every send comes
+     * back `suppressed`. This clears the opt-out rows (only those: a bounce or
+     * complaint is not the contact's to reverse), then upserts the subscription
+     * through the normal path, double opt-in included.
+     *
+     * Deliberately a separate method rather than a side effect of
+     * `upsertSubscription`, so a backfill or a model hook that re-upserts every
+     * account cannot silently resurrect addresses that opted out.
+     */
+    resubscribe(input: ResubscribeInput): Promise<{
+        removedSuppressions: number;
+    }>;
     /**
      * The writes live in `server/unsubscribe.ts` so the pending-unsubscribe
      * drain (INVARIANT 8) replays a journaled opt-out through exactly this path

package/dist/testing.cjs

@@ -14291,6 +14291,15 @@ var unsubscribeInputSchema = zod.z.object({
   source: zod.z.string().max(256).default("manual"),
   notes: zod.z.string().max(1024).optional()
 });
+var resubscribeInputSchema = zod.z.object({
+  externalId: externalIdSchema,
+  /** `marketing` clears marketing + all-scope opt-outs; `all` clears every scope. */
+  scope: zod.z.enum(["marketing", "all"]).default("marketing"),
+  source: zod.z.string().min(1).max(256),
+  consentTimestamp: zod.z.date().optional(),
+  consentIp: zod.z.string().optional(),
+  consentUserAgent: zod.z.string().optional()
+});
 var suppressInputSchema = zod.z.object({
   email: emailSchema,
   scope: unsubscribeScopeSchema,
@@ -14788,6 +14797,15 @@ function signDoiToken(payload, secret) {
 }
 
 // src/server/unsubscribe.ts
+async function clearUnsubscribeSuppressions(collections, email, scope) {
+  const scopes = scope === "all" ? ["all", "marketing", "transactional"] : ["marketing", "all"];
+  const result = await collections.suppressions.deleteMany({
+    email,
+    reason: "unsubscribed",
+    scope: { $in: scopes }
+  });
+  return result.deletedCount ?? 0;
+}
 async function applyUnsubscribe(collections, input, now = /* @__PURE__ */ new Date()) {
   const normalized = input.email;
   await collections.suppressions.updateOne(
@@ -18161,6 +18179,38 @@ var Mailer = class _Mailer {
       }
     }
   }
+  /**
+   * An explicit opt-in from a contact who unsubscribed before.
+   *
+   * `upsertSubscription` alone is not enough: an unsubscribe also writes a
+   * `mailer_suppressions` row, and the suppression check runs at enqueue
+   * time regardless of subscription status — so a contact re-subscribed
+   * through `upsertSubscription` reads as subscribed while every send comes
+   * back `suppressed`. This clears the opt-out rows (only those: a bounce or
+   * complaint is not the contact's to reverse), then upserts the subscription
+   * through the normal path, double opt-in included.
+   *
+   * Deliberately a separate method rather than a side effect of
+   * `upsertSubscription`, so a backfill or a model hook that re-upserts every
+   * account cannot silently resurrect addresses that opted out.
+   */
+  async resubscribe(input) {
+    const parsed = resubscribeInputSchema.parse(input);
+    const contact = await this.adapter.getById(parsed.externalId);
+    if (!contact) throw new Error(`adapter has no contact for externalId ${parsed.externalId}`);
+    const removedSuppressions = await clearUnsubscribeSuppressions(this.collections, contact.email, parsed.scope);
+    const { scope: _scope, ...subscription } = parsed;
+    await this.upsertSubscription(subscription);
+    if (removedSuppressions > 0) {
+      await this.audit({
+        actor: `host:${parsed.source}`,
+        action: "contact.resubscribe",
+        resource: { collection: "mailer_suppressions", id: parsed.externalId },
+        diffSummary: `${contact.email}: removed ${removedSuppressions} unsubscribed suppression${removedSuppressions === 1 ? "" : "s"} (${parsed.scope})`
+      });
+    }
+    return { removedSuppressions };
+  }
   /**
    * The writes live in `server/unsubscribe.ts` so the pending-unsubscribe
    * drain (INVARIANT 8) replays a journaled opt-out through exactly this path