@vonall/auth 0.4.0 → 0.6.0

package/dist/server/loads.js

@@ -1,22 +1,24 @@
 /**
  * The `load` functions of the auth routes, for a Product's `+page.server.ts`/`+layout.server.ts` to re-export:
- * `export { loginLoad as load } from "@vonall/auth/server";`
+ * `export { loginLoad as load } from "@vonall/auth/server";`. The layouts' loads also carry what the components need
+ * to know about the app (`authUi`: its name, locale and signup mode), so the Product passes nothing twice.
  */
 import { error, redirect } from "@sveltejs/kit";
 import { m } from "../messages.js";
-import { authInstance, registry } from "./registry.js";
-import { EINLADUNG_COOKIE, EinladungService } from "./service/einladung.service.js";
+import { contextOf } from "./context.js";
+import { EINLADUNG_COOKIE, einladungService } from "./service/einladung.service.js";
 import { isStale, SESSION_NOT_FRESH } from "../util/fresh.js";
 import { sameSitePath } from "../util/sameSite.js";
 import { isAdmin, mayInvite } from "../util/signup.js";
+const uiData = ({ appName, locale, signupMode }) => ({ appName, locale, signupMode });
 /** `/auth`: which social logins have keys, and whether a password reset mail can be sent (the link is hidden otherwise). */
-export async function authLayoutLoad() {
-    const { providers, mailer } = registry();
-    return { providers, mail: mailer.enabled };
+export async function authLayoutLoad({ locals }) {
+    const ctx = contextOf(locals);
+    return { providers: ctx.providers, mail: ctx.mailer.enabled, authUi: uiData(ctx) };
 }
 /** `/auth/login`. */
 export async function loginLoad({ locals, url, request }) {
-    const auth = authInstance();
+    const { auth } = contextOf(locals);
     // An action refused the session as too old to be trusted (reauthPath): sign it out, so the form shows. Only a session
     // that really is that old, so a link can't log anyone out.
     if (locals.session && url.searchParams.get("error") === SESSION_NOT_FRESH.toLowerCase()) {
@@ -37,20 +39,23 @@ export async function loginLoad({ locals, url, request }) {
 export async function signupLoad({ locals, cookies }) {
     if (locals.session)
         throw redirect(302, "/home");
-    const { state, einladung } = await EinladungService.signup(cookies.get(EINLADUNG_COOKIE));
-    return { state, mode: registry().signupMode, einladung: einladung ? { inviterName: einladung.inviterName } : null };
+    const ctx = contextOf(locals);
+    const { state, einladung } = await einladungService(ctx).signup(cookies.get(EINLADUNG_COOKIE));
+    return { state, mode: ctx.signupMode, einladung: einladung ? { inviterName: einladung.inviterName } : null };
 }
 /**
  * `/einladung/[token]`: the link of an Einladung. A valid one is remembered in a cookie so it survives signup with
  * email, Google or GitHub (the signup hook takes it from there).
  */
 export async function einladungLoad({ params, cookies, locals, url }) {
+    const ctx = contextOf(locals);
     const token = params.token;
     if (!token)
         throw error(404, { message: m().einladungUnbekannt, id: "unbekannt", timestamp: new Date().toISOString() });
-    const pruefung = await EinladungService.pruefen(token);
+    const pruefung = await einladungService(ctx).pruefen(token);
+    const authUi = uiData(ctx);
     if (pruefung.isErr())
-        return { fehler: pruefung.error.message, einladung: null, eingeloggt: !!locals.user };
+        return { fehler: pruefung.error.message, einladung: null, eingeloggt: !!locals.user, authUi };
     const einladung = pruefung.value;
     cookies.set(EINLADUNG_COOKIE, token, {
         path: "/",
@@ -60,18 +65,18 @@ export async function einladungLoad({ params, cookies, locals, url }) {
         secure: url.protocol === "https:",
         expires: einladung.expiresAt,
     });
-    return { fehler: null, einladung: { inviterName: einladung.inviterName }, eingeloggt: !!locals.user };
+    return { fehler: null, einladung: { inviterName: einladung.inviterName }, eingeloggt: !!locals.user, authUi };
 }
 /** `/home`: login required; the user, the session (never its token), the providers and whether the user may invite. */
 export function homeLayoutLoad({ locals }) {
     if (!locals.session || !locals.user)
         throw redirect(302, "/auth/login");
-    const { providers, signupMode } = registry();
+    const ctx = contextOf(locals);
     const user = { ...locals.user };
     // Never the session token itself: page data ends up in the HTML and in client JS
     const session = { id: locals.session.id, expiresAt: locals.session.expiresAt };
     // Whether the Invitations tab shows: the signup mode decides who creates Einladungen
-    return { user, session, providers, einladen: mayInvite(signupMode, isAdmin(locals.user)) };
+    return { user, session, providers: ctx.providers, einladen: mayInvite(ctx.signupMode, isAdmin(locals.user)), authUi: uiData(ctx) };
 }
 /** `/home/manage_user` (the Admin option): admins only. */
 export function manageUserLoad({ locals }) {

package/dist/server/repositories/EinladungRepo.d.ts

@@ -1,4 +1,6 @@
-export declare const EinladungRepo: {
+import type { AuthContext } from "../context.js";
+/** The Einladungen of the app the context belongs to. */
+export declare function einladungRepo(ctx: AuthContext): {
     insert(row: {
         id: string;
         tokenHash: string;
@@ -34,3 +36,4 @@ export declare const EinladungRepo: {
     /** Deletes an open Einladung of the user (or any, with `userId` null for the admin); false when there was none. */
     deleteOpen(id: string, userId: string | null): Promise<boolean>;
 };
+export type EinladungRepo = ReturnType<typeof einladungRepo>;

package/dist/server/repositories/EinladungRepo.js

@@ -1,74 +1,67 @@
 import { and, desc, eq, gt, isNull } from "drizzle-orm";
-import { registry } from "../registry.js";
-export const EinladungRepo = {
-    async insert(row) {
-        const { db, schema } = registry();
-        await db.insert(schema.einladung).values(row);
-    },
-    /** The Einladung with the name of its inviter, by the hash of its token. */
-    async getByTokenHash(tokenHash) {
-        const { db, schema } = registry();
-        const { einladung, user } = schema;
-        const rows = await db
-            .select({
-            id: einladung.id,
-            createdBy: einladung.createdBy,
-            inviterName: user.name,
-            expiresAt: einladung.expiresAt,
-            acceptedAt: einladung.acceptedAt,
-        })
-            .from(einladung)
-            .innerJoin(user, eq(einladung.createdBy, user.id))
-            .where(eq(einladung.tokenHash, tokenHash))
-            .limit(1);
-        return rows[0] ?? null;
-    },
-    /** Marks the Einladung as accepted, unless it already was or has expired; false when it couldn't be taken. */
-    async accept(id, userId, now) {
-        const { db, schema } = registry();
-        const { einladung } = schema;
-        const rows = await db
-            .update(einladung)
-            .set({ acceptedAt: now, acceptedBy: userId })
-            .where(and(eq(einladung.id, id), isNull(einladung.acceptedAt), gt(einladung.expiresAt, now)))
-            .returning({ id: einladung.id });
-        return rows.length === 1;
-    },
-    /** The user's Einladungen that are still open (not accepted, not expired), newest first. */
-    async listOpenBy(userId, now) {
-        const { db, schema } = registry();
-        const { einladung } = schema;
-        return await db
-            .select({ id: einladung.id, email: einladung.email, expiresAt: einladung.expiresAt, createdAt: einladung.createdAt })
-            .from(einladung)
-            .where(and(eq(einladung.createdBy, userId), isNull(einladung.acceptedAt), gt(einladung.expiresAt, now)))
-            .orderBy(desc(einladung.createdAt));
-    },
-    /** All open Einladungen with their inviter, for the admin. */
-    async listAllOpen(now) {
-        const { db, schema } = registry();
-        const { einladung, user } = schema;
-        return await db
-            .select({
-            id: einladung.id,
-            email: einladung.email,
-            inviterName: user.name,
-            expiresAt: einladung.expiresAt,
-            createdAt: einladung.createdAt,
-        })
-            .from(einladung)
-            .innerJoin(user, eq(einladung.createdBy, user.id))
-            .where(and(isNull(einladung.acceptedAt), gt(einladung.expiresAt, now)))
-            .orderBy(desc(einladung.createdAt));
-    },
-    /** Deletes an open Einladung of the user (or any, with `userId` null for the admin); false when there was none. */
-    async deleteOpen(id, userId) {
-        const { db, schema } = registry();
-        const { einladung } = schema;
-        const rows = await db
-            .delete(einladung)
-            .where(and(eq(einladung.id, id), isNull(einladung.acceptedAt), userId ? eq(einladung.createdBy, userId) : undefined))
-            .returning({ id: einladung.id });
-        return rows.length === 1;
-    },
-};
+/** The Einladungen of the app the context belongs to. */
+export function einladungRepo(ctx) {
+    const { db } = ctx;
+    const { einladung, user } = ctx.schema;
+    return {
+        async insert(row) {
+            await db.insert(einladung).values(row);
+        },
+        /** The Einladung with the name of its inviter, by the hash of its token. */
+        async getByTokenHash(tokenHash) {
+            const rows = await db
+                .select({
+                id: einladung.id,
+                createdBy: einladung.createdBy,
+                inviterName: user.name,
+                expiresAt: einladung.expiresAt,
+                acceptedAt: einladung.acceptedAt,
+            })
+                .from(einladung)
+                .innerJoin(user, eq(einladung.createdBy, user.id))
+                .where(eq(einladung.tokenHash, tokenHash))
+                .limit(1);
+            return rows[0] ?? null;
+        },
+        /** Marks the Einladung as accepted, unless it already was or has expired; false when it couldn't be taken. */
+        async accept(id, userId, now) {
+            const rows = await db
+                .update(einladung)
+                .set({ acceptedAt: now, acceptedBy: userId })
+                .where(and(eq(einladung.id, id), isNull(einladung.acceptedAt), gt(einladung.expiresAt, now)))
+                .returning({ id: einladung.id });
+            return rows.length === 1;
+        },
+        /** The user's Einladungen that are still open (not accepted, not expired), newest first. */
+        async listOpenBy(userId, now) {
+            return await db
+                .select({ id: einladung.id, email: einladung.email, expiresAt: einladung.expiresAt, createdAt: einladung.createdAt })
+                .from(einladung)
+                .where(and(eq(einladung.createdBy, userId), isNull(einladung.acceptedAt), gt(einladung.expiresAt, now)))
+                .orderBy(desc(einladung.createdAt));
+        },
+        /** All open Einladungen with their inviter, for the admin. */
+        async listAllOpen(now) {
+            return await db
+                .select({
+                id: einladung.id,
+                email: einladung.email,
+                inviterName: user.name,
+                expiresAt: einladung.expiresAt,
+                createdAt: einladung.createdAt,
+            })
+                .from(einladung)
+                .innerJoin(user, eq(einladung.createdBy, user.id))
+                .where(and(isNull(einladung.acceptedAt), gt(einladung.expiresAt, now)))
+                .orderBy(desc(einladung.createdAt));
+        },
+        /** Deletes an open Einladung of the user (or any, with `userId` null for the admin); false when there was none. */
+        async deleteOpen(id, userId) {
+            const rows = await db
+                .delete(einladung)
+                .where(and(eq(einladung.id, id), isNull(einladung.acceptedAt), userId ? eq(einladung.createdBy, userId) : undefined))
+                .returning({ id: einladung.id });
+            return rows.length === 1;
+        },
+    };
+}

package/dist/server/repositories/UserRepo.d.ts

@@ -1,5 +1,7 @@
+import type { AuthContext } from "../context.js";
 import type { AppUserClient, UserInsert } from "../../types.js";
-export declare const UserRepo: {
+/** The accounts of the app the context belongs to. */
+export declare function userRepo(ctx: AuthContext): {
     /** Every account, oldest first (the admin's list). */
     getAllUsers(): Promise<AppUserClient[]>;
     getUserById(id: string): Promise<AppUserClient | null>;
@@ -20,3 +22,4 @@ export declare const UserRepo: {
      */
     kontoLoeschen(userId: string): Promise<void>;
 };
+export type UserRepo = ReturnType<typeof userRepo>;

package/dist/server/repositories/UserRepo.js

@@ -1,9 +1,12 @@
 import { asc, count, eq } from "drizzle-orm";
-import { registry } from "../registry.js";
 import { nameFromEmail } from "../../util/names.js";
-/** The columns the client gets; the admin ones exist only with the admin option. */
-function selection() {
-    const { user } = registry().schema;
+const rows = (list) => list;
+/** The accounts of the app the context belongs to. */
+export function userRepo(ctx) {
+    const { db, admin } = ctx;
+    // Every column on the type; the admin ones are only read with the option (`ctx.admin`)
+    const { user, account } = ctx.schema;
+    /** The columns the client gets; the admin ones exist only with the admin option. */
     const base = {
         id: user.id,
         email: user.email,
@@ -14,57 +17,46 @@ function selection() {
         emailVerified: user.emailVerified,
         image: user.image,
     };
-    return registry().admin ? { ...base, role: user.role, banned: user.banned, banReason: user.banReason, banExpires: user.banExpires } : base;
+    const selection = admin ? { ...base, role: user.role, banned: user.banned, banReason: user.banReason, banExpires: user.banExpires } : base;
+    const repo = {
+        /** Every account, oldest first (the admin's list). */
+        async getAllUsers() {
+            return rows(await db.select(selection).from(user).orderBy(asc(user.createdAt)));
+        },
+        async getUserById(id) {
+            const list = rows(await db.select(selection).from(user).where(eq(user.id, id)).limit(1));
+            return list[0] ?? null;
+        },
+        async getUserFromEmail(email) {
+            const list = rows(await db.select(selection).from(user).where(eq(user.email, email)).limit(1));
+            return list[0] ?? null;
+        },
+        async countUsers() {
+            const [row] = await db.select({ n: count() }).from(user);
+            return row.n;
+        },
+        /** Admin option only. */
+        async setRole(userId, role) {
+            await db.update(user).set({ role }).where(eq(user.id, userId));
+        },
+        /** Creates a user outside better-auth's signup (tests, scripts); the first one becomes admin like any other. */
+        async insertUser(data) {
+            if (!data.name && data.email)
+                data.name = nameFromEmail(data.email);
+            await db.insert(user).values(data);
+            if (admin && data.id && (await repo.countUsers()) === 1)
+                await repo.setRole(data.id, "admin");
+        },
+        async getUserAccounts(userId) {
+            return await db.select({ id: account.id, providerId: account.providerId, updatedAt: account.updatedAt }).from(account).where(eq(account.userId, userId));
+        },
+        /**
+         * Deletes the Konto: the user with everything that belongs to them (the foreign keys of every user-owned table
+         * cascade, so a Product's own tables reference `user.id` with `onDelete: "cascade"`).
+         */
+        async kontoLoeschen(userId) {
+            await db.delete(user).where(eq(user.id, userId));
+        },
+    };
+    return repo;
 }
-const rows = (list) => list;
-export const UserRepo = {
-    /** Every account, oldest first (the admin's list). */
-    async getAllUsers() {
-        const { db, schema } = registry();
-        return rows(await db.select(selection()).from(schema.user).orderBy(asc(schema.user.createdAt)));
-    },
-    async getUserById(id) {
-        const { db, schema } = registry();
-        const list = rows(await db.select(selection()).from(schema.user).where(eq(schema.user.id, id)).limit(1));
-        return list[0] ?? null;
-    },
-    async getUserFromEmail(email) {
-        const { db, schema } = registry();
-        const list = rows(await db.select(selection()).from(schema.user).where(eq(schema.user.email, email)).limit(1));
-        return list[0] ?? null;
-    },
-    async countUsers() {
-        const { db, schema } = registry();
-        const [row] = await db.select({ n: count() }).from(schema.user);
-        return row.n;
-    },
-    /** Admin option only. */
-    async setRole(userId, role) {
-        const { db, schema } = registry();
-        await db.update(schema.user).set({ role }).where(eq(schema.user.id, userId));
-    },
-    /** Creates a user outside better-auth's signup (tests, scripts); the first one becomes admin like any other. */
-    async insertUser(data) {
-        const { db, schema, admin } = registry();
-        if (!data.name && data.email)
-            data.name = nameFromEmail(data.email);
-        await db.insert(schema.user).values(data);
-        if (admin && data.id && (await UserRepo.countUsers()) === 1)
-            await UserRepo.setRole(data.id, "admin");
-    },
-    async getUserAccounts(userId) {
-        const { db, schema } = registry();
-        return await db
-            .select({ id: schema.account.id, providerId: schema.account.providerId, updatedAt: schema.account.updatedAt })
-            .from(schema.account)
-            .where(eq(schema.account.userId, userId));
-    },
-    /**
-     * Deletes the Konto: the user with everything that belongs to them (the foreign keys of every user-owned table
-     * cascade, so a Product's own tables reference `user.id` with `onDelete: "cascade"`).
-     */
-    async kontoLoeschen(userId) {
-        const { db, schema } = registry();
-        await db.delete(schema.user).where(eq(schema.user.id, userId));
-    },
-};

package/dist/server/service/einladung.service.d.ts

@@ -1,13 +1,16 @@
 import { type Result } from "neverthrow";
+import type { AuthContext } from "../context.js";
 import type { EinladungInfo, SignupMode, SignupState } from "../../types.js";
-export declare const EINLADUNG_GUELTIG_TAGE = 14;
+import { EINLADUNG_GUELTIG_TAGE } from "../../util/signup.js";
+export { EINLADUNG_GUELTIG_TAGE };
 /** The cookie that carries an Einladung's token from its link through signup (email, Google or GitHub). */
 export declare const EINLADUNG_COOKIE = "einladung";
 export type EinladungError = {
     kind: "unbekannt" | "abgelaufen" | "angenommen";
     message: string;
 };
-export declare const EinladungService: {
+/** The Einladungen of the app the context belongs to. */
+export declare function einladungService(ctx: AuthContext): {
     /** Creates an Einladung and returns its token, shown only this once. */
     erstellen(userId: string, input?: {
         email?: string | null;
@@ -36,3 +39,4 @@ export declare const EinladungService: {
     /** Withdraws an open Einladung of the user, or any open one when `userId` is null (the admin). */
     zurueckziehen(userId: string | null, einladungId: string): Promise<Result<void, EinladungError>>;
 };
+export type EinladungService = ReturnType<typeof einladungService>;

package/dist/server/service/einladung.service.js

@@ -5,11 +5,10 @@
 import { createHash, randomBytes } from "node:crypto";
 import { err, ok } from "neverthrow";
 import { m } from "../../messages.js";
-import { registry } from "../registry.js";
-import { EinladungRepo } from "../repositories/EinladungRepo.js";
-import { UserRepo } from "../repositories/UserRepo.js";
-import { signupState } from "../../util/signup.js";
-export const EINLADUNG_GUELTIG_TAGE = 14;
+import { einladungRepo } from "../repositories/EinladungRepo.js";
+import { userRepo } from "../repositories/UserRepo.js";
+import { EINLADUNG_GUELTIG_TAGE, signupState } from "../../util/signup.js";
+export { EINLADUNG_GUELTIG_TAGE };
 /** The cookie that carries an Einladung's token from its link through signup (email, Google or GitHub). */
 export const EINLADUNG_COOKIE = "einladung";
 const hash = (token) => createHash("sha256").update(token).digest("hex");
@@ -18,49 +17,55 @@ const fehler = {
     abgelaufen: () => ({ kind: "abgelaufen", message: m().einladungAbgelaufen }),
     angenommen: () => ({ kind: "angenommen", message: m().einladungAngenommen }),
 };
-export const EinladungService = {
-    /** Creates an Einladung and returns its token, shown only this once. */
-    async erstellen(userId, input = {}, now = new Date()) {
-        const token = randomBytes(24).toString("base64url");
-        const id = crypto.randomUUID();
-        const expiresAt = new Date(now.getTime() + EINLADUNG_GUELTIG_TAGE * 24 * 60 * 60 * 1000);
-        await EinladungRepo.insert({ id, tokenHash: hash(token), createdBy: userId, email: input.email ?? null, expiresAt });
-        return { id, token, expiresAt };
-    },
-    /** What the link offers, if it can still be used. */
-    async pruefen(token, now = new Date()) {
-        const row = await EinladungRepo.getByTokenHash(hash(token));
-        if (!row)
-            return err(fehler.unbekannt());
-        if (row.acceptedAt)
-            return err(fehler.angenommen());
-        if (row.expiresAt <= now)
-            return err(fehler.abgelaufen());
-        return ok({ id: row.id, inviterName: row.inviterName, expiresAt: row.expiresAt });
-    },
-    /**
-     * Whether someone may create an account now, and if not, why (the signup mode decides, `signupState`); whether it
-     * would be the very first account; and the Einladung the token stands for, if it is usable. One count, one lookup.
-     */
-    async signup(token, options = {}) {
-        const { now = new Date(), mode = registry().signupMode, mail = registry().mailer.enabled } = options;
-        const accounts = await UserRepo.countUsers();
-        const geprueft = token ? await EinladungService.pruefen(token, now) : null;
-        const einladung = geprueft?.isOk() ? geprueft.value : null;
-        const einladungUsable = accounts > 0 && mode !== "open" && einladung !== null;
-        return { state: signupState({ mode, accounts, einladungUsable, mail }), firstAccount: accounts === 0, einladung };
-    },
-    /** Uses the Einladung for the new user: marks it as taken. */
-    async annehmen(userId, token, now = new Date()) {
-        const info = await EinladungService.pruefen(token, now);
-        if (info.isErr())
-            return err(info.error);
-        if (!(await EinladungRepo.accept(info.value.id, userId, now)))
-            return err(fehler.angenommen());
-        return ok(undefined);
-    },
-    /** Withdraws an open Einladung of the user, or any open one when `userId` is null (the admin). */
-    async zurueckziehen(userId, einladungId) {
-        return (await EinladungRepo.deleteOpen(einladungId, userId)) ? ok(undefined) : err(fehler.unbekannt());
-    },
-};
+/** The Einladungen of the app the context belongs to. */
+export function einladungService(ctx) {
+    const repo = einladungRepo(ctx);
+    const users = userRepo(ctx);
+    const service = {
+        /** Creates an Einladung and returns its token, shown only this once. */
+        async erstellen(userId, input = {}, now = new Date()) {
+            const token = randomBytes(24).toString("base64url");
+            const id = crypto.randomUUID();
+            const expiresAt = new Date(now.getTime() + EINLADUNG_GUELTIG_TAGE * 24 * 60 * 60 * 1000);
+            await repo.insert({ id, tokenHash: hash(token), createdBy: userId, email: input.email ?? null, expiresAt });
+            return { id, token, expiresAt };
+        },
+        /** What the link offers, if it can still be used. */
+        async pruefen(token, now = new Date()) {
+            const row = await repo.getByTokenHash(hash(token));
+            if (!row)
+                return err(fehler.unbekannt());
+            if (row.acceptedAt)
+                return err(fehler.angenommen());
+            if (row.expiresAt <= now)
+                return err(fehler.abgelaufen());
+            return ok({ id: row.id, inviterName: row.inviterName, expiresAt: row.expiresAt });
+        },
+        /**
+         * Whether someone may create an account now, and if not, why (the signup mode decides, `signupState`); whether it
+         * would be the very first account; and the Einladung the token stands for, if it is usable. One count, one lookup.
+         */
+        async signup(token, options = {}) {
+            const { now = new Date(), mode = ctx.signupMode, mail = ctx.mailer.enabled } = options;
+            const accounts = await users.countUsers();
+            const geprueft = token ? await service.pruefen(token, now) : null;
+            const einladung = geprueft?.isOk() ? geprueft.value : null;
+            const einladungUsable = accounts > 0 && mode !== "open" && einladung !== null;
+            return { state: signupState({ mode, accounts, einladungUsable, mail }), firstAccount: accounts === 0, einladung };
+        },
+        /** Uses the Einladung for the new user: marks it as taken. */
+        async annehmen(userId, token, now = new Date()) {
+            const info = await service.pruefen(token, now);
+            if (info.isErr())
+                return err(info.error);
+            if (!(await repo.accept(info.value.id, userId, now)))
+                return err(fehler.angenommen());
+            return ok(undefined);
+        },
+        /** Withdraws an open Einladung of the user, or any open one when `userId` is null (the admin). */
+        async zurueckziehen(userId, einladungId) {
+            return (await repo.deleteOpen(einladungId, userId)) ? ok(undefined) : err(fehler.unbekannt());
+        },
+    };
+    return service;
+}

package/dist/server/service/mail.d.ts

@@ -1,12 +1,16 @@
-export declare function sendPasswordResetEmail(user: {
-    email: string;
-    name: string;
-}, url: string): Promise<void>;
-export declare function sendVerifyEmail(user: {
-    email: string;
-    name: string;
-}, url: string): Promise<void>;
-export declare function sendEinladungEmail(inviterName: string, to: string, einladung: {
-    link: string;
-    expiresAt: Date;
-}, locale: string): Promise<void>;
+import type { AuthContext } from "../context.js";
+export declare function authMails(ctx: AuthContext): {
+    passwordReset(user: {
+        email: string;
+        name: string;
+    }, url: string): Promise<void>;
+    verify(user: {
+        email: string;
+        name: string;
+    }, url: string): Promise<void>;
+    einladung(inviterName: string, to: string, einladung: {
+        link: string;
+        expiresAt: Date;
+    }): Promise<void>;
+};
+export type AuthMails = ReturnType<typeof authMails>;

package/dist/server/service/mail.js

@@ -1,40 +1,38 @@
-/** The three mails of accounts, through the Product's mailer (`@vonall/mail`). */
+/** The three mails of accounts, through the Product's mailer (`@vonall/mail`), in the app's name and locale. */
 import { renderMail } from "@vonall/mail";
 import { m } from "../../messages.js";
-import { registry } from "../registry.js";
 import InvitationEmail from "../../templates/InvitationEmail.svelte";
 import ResetPasswordEmail from "../../templates/ResetPasswordEmail.svelte";
 import VerifyEmailEmail from "../../templates/VerifyEmailEmail.svelte";
-function footer() {
-    const { appName, origin } = registry();
-    return { appName, appLink: origin };
-}
-const footerText = (appName) => `\n---\n${appName}\n`;
-export async function sendPasswordResetEmail(user, url) {
-    const { mailer, appName } = registry();
-    await mailer.send({
-        to: user.email,
-        subject: m().resetSubject(appName),
-        text: m().resetText(user.name, appName, url) + footerText(appName),
-        html: renderMail(ResetPasswordEmail, { recipientName: user.name, link: url, ...footer() }),
-    });
-}
-export async function sendVerifyEmail(user, url) {
-    const { mailer, appName } = registry();
-    await mailer.send({
-        to: user.email,
-        subject: m().verifySubject(appName),
-        text: m().verifyText(user.name, appName, url) + footerText(appName),
-        html: renderMail(VerifyEmailEmail, { recipientName: user.name, link: url, ...footer() }),
-    });
-}
-export async function sendEinladungEmail(inviterName, to, einladung, locale) {
-    const { mailer, appName } = registry();
-    const validUntil = new Intl.DateTimeFormat(locale, { dateStyle: "long" }).format(einladung.expiresAt);
-    await mailer.send({
-        to,
-        subject: m().einladungSubject(inviterName, appName),
-        text: m().einladungText(inviterName, appName, einladung.link, validUntil) + footerText(appName),
-        html: renderMail(InvitationEmail, { inviterName, link: einladung.link, validUntil, ...footer() }),
-    });
+export function authMails(ctx) {
+    const { mailer, appName, origin, locale } = ctx;
+    const footer = { appName, appLink: origin };
+    const footerText = `\n---\n${appName}\n`;
+    return {
+        async passwordReset(user, url) {
+            await mailer.send({
+                to: user.email,
+                subject: m().resetSubject(appName),
+                text: m().resetText(user.name, appName, url) + footerText,
+                html: renderMail(ResetPasswordEmail, { recipientName: user.name, link: url, ...footer }),
+            });
+        },
+        async verify(user, url) {
+            await mailer.send({
+                to: user.email,
+                subject: m().verifySubject(appName),
+                text: m().verifyText(user.name, appName, url) + footerText,
+                html: renderMail(VerifyEmailEmail, { recipientName: user.name, link: url, ...footer }),
+            });
+        },
+        async einladung(inviterName, to, einladung) {
+            const validUntil = new Intl.DateTimeFormat(locale, { dateStyle: "long" }).format(einladung.expiresAt);
+            await mailer.send({
+                to,
+                subject: m().einladungSubject(inviterName, appName),
+                text: m().einladungText(inviterName, appName, einladung.link, validUntil) + footerText,
+                html: renderMail(InvitationEmail, { inviterName, link: einladung.link, validUntil, ...footer }),
+            });
+        },
+    };
 }