Kundenkonto: Mailadresse bestätigen, Gastbestellungen übernehmen, Passwort vergessen

Wer als Gast bestellt und später ein Konto mit derselben Adresse anlegt,
sah dort bisher nichts: Medusa legt einen neuen Kundendatensatz an, die
Gastbestellungen bleiben am alten. Gast-Abos ließen sich dadurch nur
kündigen, nie pausieren oder ändern.

Jetzt:
- Nach der Registrierung geht ein Bestätigungslink raus (Medusas
  eingebaute Verifizierung, Code nur als Hash gespeichert, einmalig,
  15 Minuten gültig). Im Konto ein Hinweis mit "Link erneut senden".
- Erst mit bestätigter Adresse werden Gastbestellungen und Gast-Abos
  derselben Adresse ins Konto übernommen — bei jedem Aufruf von Konto-
  und Abo-Seite, damit auch spätere Gastbestellungen ankommen. Ohne
  Bestätigung könnte jeder mit einer fremden Adresse deren Bestellungen
  sehen.
- Bestätigungsmails nur an die Adresse des eigenen Kontos, sonst ließe
  sich über Medusas offene Route Post an Fremde auslösen.
- Passwort vergessen: Mail mit Link (eingebaut in Medusa, nur der
  Versand fehlte) und zwei Seiten im Frontend.
- Dankeseite und Abo-Rückkehrseite weisen Gäste aufs Kundenkonto hin.

Im Browser durchgespielt: Gast mit drei Bestellungen und Abo
registriert sich, bestätigt, sieht alles im Konto; Link zweimal benutzt
wird abgelehnt; Passwort zurückgesetzt, Anmeldung klappt.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
This commit is contained in:
torbinus
2026-10-26 10:44:49 +01:00
parent 74b0939614
commit 596c8f6ee3
15 changed files with 592 additions and 4 deletions
@@ -0,0 +1,76 @@
import { AuthenticatedMedusaRequest, MedusaResponse } from "@medusajs/framework/http";
import { Modules } from "@medusajs/framework/utils";
import { requestVerificationWorkflow } from "@medusajs/core-flows";
import {
EMAIL_VERIFICATION,
istEmailBestaetigt,
normalisiereEmail,
uebernimmGastbestellungen,
} from "../../../../../lib/gastbestellungen";
/** Frühestens nach dieser Zeit lässt sich ein neuer Link anfordern. */
const SPERRE_MS = 60_000;
async function kundeLaden(req: AuthenticatedMedusaRequest) {
const customers: any = req.scope.resolve(Modules.CUSTOMER);
return customers.retrieveCustomer(req.auth_context.actor_id, { select: ["id", "email"] });
}
/**
* Stand der Mailbestätigung. Ist die Adresse bestätigt, werden dabei
* Gastbestellungen und Gast-Abos mit derselben Adresse ins Konto übernommen —
* bei jedem Aufruf, damit auch spätere Gastbestellungen ankommen.
*
* Liegt unter /customers/me* und ist damit schon von Medusa geschützt.
*/
export async function GET(req: AuthenticatedMedusaRequest, res: MedusaResponse) {
const kunde = await kundeLaden(req);
const bestaetigt = await istEmailBestaetigt(req.scope, req.auth_context.auth_identity_id, kunde.email);
if (!bestaetigt) {
return res.json({ verified: false });
}
const uebernommen = await uebernimmGastbestellungen(req.scope, kunde);
if (uebernommen.bestellungen || uebernommen.abos) {
req.scope
.resolve("logger")
.info(
`[konto] ${kunde.id}: ${uebernommen.bestellungen} Gastbestellung(en), ${uebernommen.abos} Abo(s) übernommen.`
);
}
res.json({ verified: true, uebernommen });
}
/**
* Schickt einen Bestätigungslink an die Adresse des Kontos. Die Adresse kommt
* bewusst aus dem Konto, nicht aus der Anfrage: sonst ließen sich Mails an
* beliebige Adressen auslösen.
*/
export async function POST(req: AuthenticatedMedusaRequest, res: MedusaResponse) {
const kunde = await kundeLaden(req);
const authIdentityId = req.auth_context.auth_identity_id;
const email = normalisiereEmail(kunde.email);
const auth: any = req.scope.resolve(Modules.AUTH);
const [vorhanden] = await auth.listAuthVerifications(
{ auth_identity_id: authIdentityId, entity_type: EMAIL_VERIFICATION.entity_type, entity_id: email },
{ take: 1 }
);
if (vorhanden?.verified_at) {
return res.json({ verified: true });
}
if (vorhanden && Date.now() - new Date(vorhanden.requested_at).getTime() < SPERRE_MS) {
return res.status(429).json({ message: "Bitte warten Sie eine Minute, bevor Sie einen neuen Link anfordern." });
}
// Der Link selbst geht über den Subscriber auf auth.verification_requested.
await requestVerificationWorkflow(req.scope).run({
input: {
auth_identity_id: authIdentityId,
entity_id: email,
entity_type: EMAIL_VERIFICATION.entity_type,
code_provider: EMAIL_VERIFICATION.code_provider,
},
});
res.status(201).json({ verified: false, sent: true });
}
@@ -0,0 +1,67 @@
import { Modules } from "@medusajs/framework/utils";
import { SUBSCRIPTION_MODULE } from "../modules/subscription";
/** So steht die Bestätigung der Mailadresse im Auth-Modul. */
export const EMAIL_VERIFICATION = { entity_type: "email", code_provider: "token" } as const;
export function normalisiereEmail(email: string): string {
return email.trim().toLowerCase();
}
/**
* Ob die Adresse dieses Kontos bestätigt ist — über Medusas eingebaute
* Verifizierung (auth_verification), nicht über ein eigenes Feld.
*/
export async function istEmailBestaetigt(
container: any,
authIdentityId: string,
email: string
): Promise<boolean> {
const auth: any = container.resolve(Modules.AUTH);
const [eintrag] = await auth.listAuthVerifications(
{
auth_identity_id: authIdentityId,
entity_type: EMAIL_VERIFICATION.entity_type,
entity_id: normalisiereEmail(email),
},
{ take: 1 }
);
return Boolean(eintrag?.verified_at);
}
/**
* Hängt Gastbestellungen und Gast-Abos mit derselben Mailadresse an das
* Konto. Nur aufrufen, wenn die Adresse bestätigt ist — sonst könnte sich
* jeder mit einer fremden Adresse registrieren und deren Bestellungen sehen.
*
* Mehrfach aufrufbar: Was schon am Konto hängt, wird nicht mehr gefunden.
*/
export async function uebernimmGastbestellungen(
container: any,
kunde: { id: string; email: string }
): Promise<{ bestellungen: number; abos: number }> {
const customers: any = container.resolve(Modules.CUSTOMER);
const orders: any = container.resolve(Modules.ORDER);
const subscriptions: any = container.resolve(SUBSCRIPTION_MODULE);
const email = normalisiereEmail(kunde.email);
// ilike wegen Groß-/Kleinschreibung; "_" in Adressen ist dort ein
// Platzhalter, deshalb danach noch exakt vergleichen.
const gaeste = (
await customers.listCustomers({ has_account: false, email: { $ilike: email } }, { select: ["id", "email"] })
).filter((c: any) => c.email && normalisiereEmail(c.email) === email);
const gastIds = gaeste.map((c: any) => c.id);
if (!gastIds.length) return { bestellungen: 0, abos: 0 };
const offen = await orders.listOrders({ customer_id: gastIds }, { select: ["id"] });
if (offen.length) {
await orders.updateOrders(offen.map((o: any) => ({ id: o.id, customer_id: kunde.id })));
}
const abos = await subscriptions.listSubscriptions({ customer_id: gastIds });
for (const abo of abos) {
await subscriptions.updateSubscriptions({ id: abo.id, customer_id: kunde.id });
}
return { bestellungen: offen.length, abos: abos.length };
}
@@ -431,6 +431,69 @@ export function kuendigungsbestaetigung(k: Kuendigung) {
return { subject: "Bestätigung Ihrer Kündigung – place4bees Honig-Abo", html: htmlInhalt, text };
}
/** Eine Mail mit genau einem Knopf — für Bestätigungs- und Zurücksetzen-Links. */
function linkMail(k: { titel: string; absatz: string; knopf: string; link: string; hinweis: string }) {
const htmlInhalt = RAHMEN(`
<h1 style="margin:0 0 4px;font-size:22px">${k.titel}</h1>
<p style="margin:24px 0 0">Hallo,</p>
<p style="margin:12px 0 0">${k.absatz}</p>
<p style="margin:24px 0 0">
<a href="${html(k.link)}" style="display:inline-block;background:#f2a900;color:#1a1a1a;text-decoration:none;font-weight:bold;padding:12px 22px;border-radius:6px">${k.knopf}</a>
</p>
<p style="margin:16px 0 0;color:#6b6b66;font-size:13px">
Der Link gilt 15 Minuten. Funktioniert der Knopf nicht, kopieren Sie
diese Adresse in Ihren Browser:<br />
<span style="word-break:break-all">${html(k.link)}</span>
</p>
<p style="margin:16px 0 0;color:#6b6b66;font-size:13px">${k.hinweis}</p>`);
const text = [
k.titel,
"",
"Hallo,",
"",
k.absatz,
"",
k.link,
"",
"Der Link gilt 15 Minuten.",
k.hinweis,
"",
`${SHOP.name} · ${SHOP.web} · ${SHOP.email}`,
].join("\n");
return { html: htmlInhalt, text };
}
/** Bestätigung der Mailadresse nach der Registrierung. */
export function emailBestaetigenMail(link: string) {
return {
subject: "Bitte bestätigen Sie Ihre E-Mail-Adresse – place4bees",
...linkMail({
titel: "E-Mail-Adresse bestätigen",
absatz:
"bitte bestätigen Sie, dass diese Adresse zu Ihrem place4bees-Konto gehört. Danach sehen Sie dort auch Bestellungen und Abos, die Sie ohne Anmeldung mit dieser Adresse abgeschlossen haben.",
knopf: "Adresse bestätigen",
link,
hinweis: "Sie haben kein Konto angelegt? Dann können Sie diese E-Mail ignorieren.",
}),
};
}
/** Link zum Zurücksetzen des Passworts. */
export function passwortZuruecksetzenMail(link: string) {
return {
subject: "Passwort zurücksetzen – place4bees",
...linkMail({
titel: "Neues Passwort festlegen",
absatz: "für Ihr place4bees-Konto wurde ein neues Passwort angefordert. Über diesen Link legen Sie es fest.",
knopf: "Neues Passwort festlegen",
link,
hinweis: "Sie haben nichts angefordert? Dann ignorieren Sie diese E-Mail — Ihr Passwort bleibt unverändert.",
}),
};
}
/** Versandnachricht an den Beschenkten — dieselbe Sendung, ohne Beträge. */
export function geschenkVersandnachricht(
empfaengerName: string,
@@ -0,0 +1,74 @@
import type { SubscriberArgs, SubscriberConfig } from "@medusajs/framework";
import { Modules } from "@medusajs/framework/utils";
import { emailBestaetigenMail, passwortZuruecksetzenMail } from "../lib/order-emails";
import { EMAIL_VERIFICATION, normalisiereEmail } from "../lib/gastbestellungen";
type Daten = {
// auth.verification_requested
auth_identity_id?: string;
entity_id?: string;
entity_type?: string;
code?: string;
// auth.password_reset
actor_type?: string;
token?: string;
};
/**
* Mails rund ums Kundenkonto: Bestätigung der Mailadresse und Passwort
* zurücksetzen. Beide Abläufe sind in Medusa eingebaut, nur der Versand
* fehlt — Medusa löst ein Ereignis mit dem Code aus und überlässt die Mail
* dem Shop.
*/
export default async function kontoEmails({ event, container }: SubscriberArgs<Daten>) {
const logger = container.resolve("logger");
const storefront = process.env.STOREFRONT_URL ?? "http://localhost:4321";
const daten = event.data;
try {
let an: string | null = null;
let inhalt: { subject: string; html: string; text: string } | null = null;
let vorlage = "";
if (event.name === "auth.verification_requested") {
// Ohne Code war die Adresse schon bestätigt — nichts zu schicken.
if (daten.entity_type !== EMAIL_VERIFICATION.entity_type || !daten.code || !daten.entity_id) return;
// Nur an die Adresse des eigenen Kontos. Medusas offene Route
// /auth/verification/request nimmt jede Adresse an; ohne diese Prüfung
// ließe sich darüber Post an Fremde auslösen.
const auth: any = container.resolve(Modules.AUTH);
const identitaet = await auth.retrieveAuthIdentity(daten.auth_identity_id);
const kundeId = identitaet?.app_metadata?.customer_id;
if (!kundeId) return;
const kunde = await container.resolve<any>(Modules.CUSTOMER).retrieveCustomer(kundeId, { select: ["email"] });
if (normalisiereEmail(kunde.email) !== normalisiereEmail(daten.entity_id)) {
logger.warn(`[mail] Bestätigung für fremde Adresse bei ${kundeId} verworfen.`);
return;
}
an = kunde.email;
vorlage = "email-verification";
inhalt = emailBestaetigenMail(`${storefront}/konto/bestaetigen?code=${encodeURIComponent(daten.code)}`);
} else if (event.name === "auth.password_reset") {
// Admin-Konten setzen ihr Passwort über die Admin-Oberfläche zurück.
if (daten.actor_type !== "customer" || !daten.token || !daten.entity_id) return;
an = daten.entity_id;
vorlage = "password-reset";
inhalt = passwortZuruecksetzenMail(`${storefront}/konto/passwort-neu?token=${encodeURIComponent(daten.token)}`);
}
if (!an || !inhalt) return;
const notification: any = container.resolve(Modules.NOTIFICATION);
await notification.createNotifications({ to: an, channel: "email", template: vorlage, content: inhalt });
logger.info(`[mail] ${vorlage} an ${an}.`);
} catch (error) {
logger.error(
`[mail] ${event.name} fehlgeschlagen: ${error instanceof Error ? error.message : String(error)}`
);
}
}
export const config: SubscriberConfig = {
event: ["auth.verification_requested", "auth.password_reset"],
};