@revenexx/cover 0.1.0

package/server/services/MockB2BContextService.ts

@@ -0,0 +1,149 @@
+import type { B2BContext, ApprovalLimit, ApprovalWorkflow, CostCenter, OrganizationSettings, Requisition } from "../../app/interfaces/b2b";
+import type { AuthRole } from "../../app/interfaces/auth";
+
+import type { IB2BContextService, IRequisitionService } from "../interfaces/b2bContext";
+
+interface OrganizationConfig {
+	name: string;
+	settings: OrganizationSettings;
+	costCenters: CostCenter[];
+}
+
+interface PersonaConfig {
+	id: string;
+	name: string;
+	email: string;
+	role: AuthRole;
+	costCenterIds?: string[];
+	defaultCostCenterId?: string | null;
+	workflowIds?: string[];
+	approvalLimits?: ApprovalLimit[];
+}
+
+const GUEST_ROLE = null;
+
+/**
+ * Builds the B2B context from the bundled demo organization, personas and
+ * workflows. An override for the organization settings can be injected per
+ * request (demo shop dev panel) via the constructor.
+ */
+export class MockB2BContextService implements IB2BContextService {
+	constructor(private readonly settingsOverride?: Partial<OrganizationSettings>) {}
+
+	async getContext(userId: string | null): Promise<B2BContext> {
+		const org = await readCoverConfigJson<OrganizationConfig>("account/organization.json");
+		const settings = this.mergeSettings(org.settings);
+
+		if (!userId) {
+			return {
+				role: GUEST_ROLE,
+				settings,
+				costCenters: [],
+				defaultCostCenterId: null,
+				approvalLimits: [],
+				workflows: [],
+			};
+		}
+
+		const personas = await readCoverConfigJson<PersonaConfig[]>("account/personas.json");
+		const persona = personas.find(p => p.id === userId);
+		const overrides = await readGovernanceOverrides();
+
+		const baseWorkflows = await readCoverConfigJson<ApprovalWorkflow[]>("account/workflows.json");
+		const allWorkflows = [
+			...baseWorkflows.map(wf => ({ ...wf, ...overrides.workflowPatches[wf.id] })),
+			...overrides.workflows,
+		];
+
+		// Account-created cost centers belong to the whole organization;
+		// bundled ones follow the persona assignment. Patches overlay both.
+		const costCenters = settings.costCenters.enabled
+			? [
+					...org.costCenters.filter(cc => (persona?.costCenterIds ?? []).includes(cc.id)),
+					...overrides.costCenters,
+				].map(cc => ({ ...cc, ...overrides.costCenterPatches[cc.id] }))
+			: [];
+
+		// Approval limits only apply when actually ordering — requesters never
+		// order directly, so their context carries none (limits are not
+		// checked for requisitions).
+		const limitsApply = settings.approvals.enabled && persona?.role !== "requester";
+
+		const costCenterLimits = limitsApply
+			? costCenters.flatMap(cc => (cc.limit ? [cc.limit] : []))
+			: [];
+
+		const personaLimits = limitsApply
+			? [
+					...(persona?.approvalLimits ?? []),
+					...overrides.approvalLimits.filter(l =>
+						l.subject.type === "user" && l.subject.userId === userId,
+					),
+				]
+			: [];
+
+		return {
+			role: persona?.role ?? GUEST_ROLE,
+			settings,
+			costCenters,
+			defaultCostCenterId: settings.costCenters.enabled
+				? (persona?.defaultCostCenterId ?? null)
+				: null,
+			approvalLimits: [...personaLimits, ...costCenterLimits].filter(l => l.active),
+			// Membership: listed in the persona config OR participating in a
+			// workflow step (account-created workflows reference users directly).
+			workflows: settings.workflows.enabled
+				? allWorkflows.filter(wf =>
+						(persona?.workflowIds ?? []).includes(wf.id)
+						|| wf.steps.some(step => step.users.some(u => u.id === userId)),
+					)
+				: [],
+		};
+	}
+
+	private mergeSettings(base: OrganizationSettings): OrganizationSettings {
+		const o = this.settingsOverride;
+		if (!o) {
+			return base;
+		}
+		return {
+			costCenters: { ...base.costCenters, ...o.costCenters },
+			approvals: { ...base.approvals, ...o.approvals },
+			workflows: { ...base.workflows, ...o.workflows },
+			cart: { ...base.cart, ...o.cart },
+			checkout: {
+				...base.checkout,
+				...o.checkout,
+				guestOrdering: { ...base.checkout.guestOrdering, ...o.checkout?.guestOrdering },
+			},
+		};
+	}
+}
+
+/** Serves the bundled demo requisitions, filtered by workflow membership. */
+export class MockRequisitionService implements IRequisitionService {
+	async list(userId: string): Promise<Requisition[]> {
+		const personas = await readCoverConfigJson<PersonaConfig[]>("account/personas.json");
+		const persona = personas.find(p => p.id === userId);
+		if (!persona) {
+			return [];
+		}
+		const requisitions = await readCoverMutableJson<Requisition[]>("account/requisitions.json");
+		const overrides = await readGovernanceOverrides();
+		const memberOf = new Set([
+			...(persona.workflowIds ?? []),
+			...overrides.workflows
+				.filter(wf => wf.steps.some(step => step.users.some(u => u.id === userId)))
+				.map(wf => wf.id),
+		]);
+		// Orderers see requisitions of workflows they belong to; requesters
+		// see their own.
+		return requisitions.filter(r =>
+			memberOf.has(r.workflowId) || r.requestedBy.id === userId,
+		);
+	}
+
+	async listOpen(userId: string): Promise<Requisition[]> {
+		return (await this.list(userId)).filter(r => r.status === "open");
+	}
+}

package/server/services/MockCartCalculationService.ts

@@ -0,0 +1,395 @@
+import type { ApprovalLimitEvaluation, B2BContext } from "../../app/interfaces/b2b";
+import type {
+	CalculatedCartLine,
+	CartCalculation,
+	CartCalculationRequest,
+	CartLineHint,
+	CartMessage,
+	CartTotalRow,
+	PriceLabelCode,
+} from "../../app/interfaces/cart-calculation";
+import type { CartItem } from "../../app/interfaces/cart-item";
+
+import type { ICartCalculationService } from "../interfaces/cartCalculation";
+
+/* ------------------------------------------------------------------ */
+/* Demo rule tables — stand-ins for ERP master data                    */
+/* ------------------------------------------------------------------ */
+
+/** Minimum quantities / packaging steps per product. */
+const QUANTITY_RULES: Record<string, { minQuantity: number; step: number }> = {
+	6919: { minQuantity: 5, step: 5 }, // Nokia G42 — bulk-only demo article
+};
+
+/** Price labels overriding the price display (G/E/A semantics). */
+const PRICE_LABELS: Record<string, PriceLabelCode> = {
+	6841: "on-request", // Sony Xperia 1 VI — price on request
+};
+
+/** Items outside the negotiated catalog (trigger non-catalog limits). */
+const NON_CATALOG_IDS = new Set<string>(["6984"]); // Dell XPS 15
+
+/** Per-unit recycling fee demo (battery-powered devices). */
+const SURCHARGE_SKU_PREFIXES = ["IP-", "RX-"];
+const SURCHARGE_PER_UNIT = 2.5;
+
+const DISCOUNT_THRESHOLD = 1000;
+const DISCOUNT_RATE = 0.03;
+
+// Free shipping from FREE_SHIPPING_THRESHOLD net (the topbar promise);
+// below it standard delivery costs a flat fee. Express always costs.
+const FREE_SHIPPING_THRESHOLD = 100;
+const STANDARD_SHIPPING_FEE = 6.9;
+const EXPRESS_SHIPPING_FEE = 9.9;
+
+const DEFAULT_TAX_RATE = 19;
+
+interface ProductListEntry {
+	product: { id: number }[];
+	stocks?: { quantity?: number }[];
+}
+
+const r2 = (n: number): number => Math.round(n * 100) / 100;
+
+const normalizeRate = (rate: number | undefined): number => {
+	if (typeof rate !== "number" || !Number.isFinite(rate) || rate < 0) {
+		return DEFAULT_TAX_RATE;
+	}
+	// Round to two decimals — 0.07 * 100 must read as 7, not 7.000000000000001.
+	const percent = rate <= 1 ? rate * 100 : rate;
+	return Math.round(percent * 100) / 100;
+};
+
+const tieredUnitPrice = (item: CartItem, quantity: number): number => {
+	if (!item.priceTiers?.length) {
+		return item.price;
+	}
+	let effective = item.price;
+	for (const tier of item.priceTiers) {
+		if (quantity >= tier.minQuantity) {
+			effective = tier.unitPrice;
+		}
+		else {
+			break;
+		}
+	}
+	return effective;
+};
+
+/**
+ * Computes the full cart picture from the bundled demo data — the
+ * "non-ERP tenant" calculation path. ERP-backed implementations replace
+ * this wholesale and map their document response into the same shape.
+ */
+export class MockCartCalculationService implements ICartCalculationService {
+	async calculate(
+		request: CartCalculationRequest,
+		context: B2BContext,
+		locale: string,
+	): Promise<CartCalculation> {
+		await preloadLocaleNamespaces(locale, ["cart"]);
+		const t = (key: string, params?: Record<string, string | number>) =>
+			serverT(key, locale, "cart", params);
+
+		const stockById = await this.loadStock();
+		const { settings, role } = context;
+
+		const skuCounts = new Map<string, number>();
+		for (const item of request.items) {
+			skuCounts.set(item.sku ?? "", (skuCounts.get(item.sku ?? "") ?? 0) + 1);
+		}
+
+		/* ---- lines ---------------------------------------------------- */
+		const lines: CalculatedCartLine[] = request.items.map((item) => {
+			const hints: CartLineHint[] = [];
+
+			const rule = QUANTITY_RULES[item.id];
+			let quantity = item.quantity;
+			if (rule) {
+				const stepped = Math.max(
+					rule.minQuantity,
+					Math.ceil(quantity / rule.step) * rule.step,
+				);
+				if (stepped !== quantity) {
+					quantity = stepped;
+					hints.push({
+						type: "quantity-adjusted",
+						messageKey: "calc.hints.quantityAdjusted",
+						params: { quantity, min: rule.minQuantity, step: rule.step },
+					});
+				}
+			}
+
+			const labelCode = PRICE_LABELS[item.id];
+			const unitPrice = labelCode ? 0 : tieredUnitPrice(item, quantity);
+			const lineTotal = r2(unitPrice * quantity);
+
+			const surcharges = !labelCode && SURCHARGE_SKU_PREFIXES.some(p => (item.sku ?? "").startsWith(p))
+				? [{ name: t("calc.recyclingFee"), amountPerUnit: SURCHARGE_PER_UNIT }]
+				: [];
+
+			const stock = stockById.get(item.id) ?? 0;
+			const availability = stock <= 0
+				? { state: "out-of-stock" as const, availableQuantity: 0, deliveryDays: 14 }
+				: stock < quantity
+					? { state: "partial" as const, availableQuantity: stock, deliveryDays: 7 }
+					: { state: "in-stock" as const, availableQuantity: stock, deliveryDays: 2 };
+
+			if ((skuCounts.get(item.sku ?? "") ?? 0) > 1) {
+				hints.push({ type: "duplicate", messageKey: "calc.hints.duplicate" });
+			}
+
+			if (settings.costCenters.enabled && settings.costCenters.required && !item.costCenterId) {
+				hints.push({ type: "missing-cost-center", messageKey: "calc.hints.missingCostCenter" });
+			}
+
+			return {
+				id: item.id,
+				quantity: item.quantity,
+				...(quantity !== item.quantity ? { adjustedQuantity: quantity } : {}),
+				unitPrice,
+				lineTotal,
+				...(labelCode
+					? { priceLabel: { code: labelCode, label: t(`calc.priceLabels.${labelCode}`) } }
+					: {}),
+				surcharges,
+				availability,
+				hints,
+			};
+		});
+
+		const effectiveQty = (line: CalculatedCartLine) => line.adjustedQuantity ?? line.quantity;
+
+		/* ---- totals (spec order) -------------------------------------- */
+		const totals: CartTotalRow[] = [];
+
+		const subtotal = r2(lines.reduce((sum, l) => sum + l.lineTotal, 0));
+		totals.push({ key: "subtotal", label: t("calc.totals.subtotal"), amount: subtotal, alwaysVisible: true });
+
+		const surchargeSum = r2(lines.reduce(
+			(sum, l) => sum + l.surcharges.reduce((s, c) => s + c.amountPerUnit * effectiveQty(l), 0),
+			0,
+		));
+		if (surchargeSum > 0) {
+			totals.push({ key: "surcharge", label: t("calc.totals.surcharges"), amount: surchargeSum });
+		}
+
+		const minOrderValue = settings.cart.minOrderValue;
+		const minOrderCharge = minOrderValue > 0 && subtotal > 0 && subtotal < minOrderValue
+			? r2(minOrderValue - subtotal)
+			: 0;
+		if (minOrderCharge > 0) {
+			totals.push({
+				key: "min-order-value",
+				label: t("calc.totals.minOrderValue"),
+				amount: minOrderCharge,
+				meta: { threshold: minOrderValue, missing: minOrderCharge },
+			});
+		}
+
+		const discount = subtotal >= DISCOUNT_THRESHOLD
+			? r2(subtotal * DISCOUNT_RATE)
+			: 0;
+		if (discount > 0) {
+			totals.push({
+				key: "discount",
+				label: t("calc.totals.discount", { percent: DISCOUNT_RATE * 100 }),
+				amount: -discount,
+			});
+		}
+
+		const shipping = (request.deliveryMethod ?? "standard") === "express"
+			? EXPRESS_SHIPPING_FEE
+			: subtotal >= FREE_SHIPPING_THRESHOLD ? 0 : STANDARD_SHIPPING_FEE;
+		totals.push({ key: "shipping", label: t("calc.totals.shipping"), amount: shipping, alwaysVisible: true });
+
+		// Taxable base per rate: line totals + line surcharges, discount applied
+		// proportionally; document-level charges taxed at the default rate.
+		const discountFactor = subtotal > 0 ? 1 - discount / subtotal : 1;
+		const basePerRate = new Map<number, number>();
+		for (let i = 0; i < lines.length; i++) {
+			const line = lines[i]!;
+			const item = request.items[i]!;
+			if (line.priceLabel) {
+				continue;
+			}
+			const rate = normalizeRate(item.taxRate);
+			const lineSurcharge = line.surcharges.reduce((s, c) => s + c.amountPerUnit * effectiveQty(line), 0);
+			const base = (line.lineTotal * discountFactor) + lineSurcharge;
+			basePerRate.set(rate, (basePerRate.get(rate) ?? 0) + base);
+		}
+		const docCharges = minOrderCharge + shipping;
+		if (docCharges > 0) {
+			basePerRate.set(DEFAULT_TAX_RATE, (basePerRate.get(DEFAULT_TAX_RATE) ?? 0) + docCharges);
+		}
+
+		let taxSum = 0;
+		for (const [rate, base] of [...basePerRate.entries()].sort((a, b) => a[0] - b[0])) {
+			const amount = r2(base * (rate / 100));
+			if (amount <= 0 && rate <= 0) {
+				continue;
+			}
+			taxSum += amount;
+			totals.push({
+				key: "tax",
+				label: t("calc.totals.tax", { percent: rate }),
+				amount,
+				meta: { rate },
+			});
+		}
+
+		const netTotal = r2(subtotal + surchargeSum + minOrderCharge - discount + shipping);
+		const total = r2(netTotal + taxSum);
+		totals.push({ key: "total", label: t("calc.totals.total"), amount: total, alwaysVisible: true });
+
+		/* ---- orderability ---------------------------------------------- */
+		const messages: CartMessage[] = [];
+		let orderable = true;
+
+		if (settings.costCenters.enabled && settings.costCenters.required && role) {
+			const missing = lines.some(l => l.hints.some(h => h.type === "missing-cost-center"));
+			if (context.costCenters.length === 0) {
+				orderable = false;
+				messages.push({
+					severity: "error",
+					code: "cost-centers-unassigned",
+					messageKey: "calc.messages.costCentersUnassigned",
+				});
+			}
+			else if (missing) {
+				orderable = false;
+				messages.push({
+					severity: "warning",
+					code: "cost-center-required",
+					messageKey: "calc.messages.costCenterRequired",
+				});
+			}
+		}
+
+		/* ---- approval limits -------------------------------------------- */
+		const approvalLimits = settings.approvals.enabled && role && role !== "requester"
+			? this.evaluateApprovalLimits(context, request.items, lines, netTotal)
+			: [];
+
+		/* ---- spend incentives (revenue nudges for the summary) ---------- */
+		const incentives = [
+			{
+				key: "free-shipping" as const,
+				label: t("calc.incentives.freeShipping"),
+				threshold: FREE_SHIPPING_THRESHOLD,
+				missing: r2(Math.max(0, FREE_SHIPPING_THRESHOLD - subtotal)),
+				reached: subtotal >= FREE_SHIPPING_THRESHOLD,
+			},
+			{
+				key: "volume-discount" as const,
+				label: t("calc.incentives.volumeDiscount", { percent: DISCOUNT_RATE * 100 }),
+				threshold: DISCOUNT_THRESHOLD,
+				missing: r2(Math.max(0, DISCOUNT_THRESHOLD - subtotal)),
+				reached: subtotal >= DISCOUNT_THRESHOLD,
+			},
+		];
+
+		return {
+			currency: "EUR",
+			lines,
+			totals,
+			orderable,
+			messages,
+			approvalLimits,
+			incentives,
+		};
+	}
+
+	private evaluateApprovalLimits(
+		context: B2BContext,
+		items: CartItem[],
+		lines: CalculatedCartLine[],
+		netTotal: number,
+	): ApprovalLimitEvaluation[] {
+		const triggered: ApprovalLimitEvaluation[] = [];
+		const maxUnitPrice = Math.max(0, ...lines.filter(l => !l.priceLabel).map(l => l.unitPrice));
+		const hasNonCatalog = items.some(i => NON_CATALOG_IDS.has(i.id) || i.nonCatalog);
+
+		const lineTotalByCostCenter = new Map<string, number>();
+		for (let i = 0; i < lines.length; i++) {
+			const cc = items[i]!.costCenterId;
+			if (cc) {
+				lineTotalByCostCenter.set(cc, r2((lineTotalByCostCenter.get(cc) ?? 0) + lines[i]!.lineTotal));
+			}
+		}
+
+		for (const limit of context.approvalLimits) {
+			let entry: ApprovalLimitEvaluation | null = null;
+
+			switch (limit.type) {
+				case "order-value": {
+					const threshold = limit.maxAmount ?? 0;
+					entry = {
+						limitId: limit.id, type: limit.type, label: limit.label,
+						status: netTotal > threshold ? "exceeded" : "within",
+						threshold, actual: netTotal,
+						...(netTotal > threshold ? { exceededBy: r2(netTotal - threshold) } : {}),
+						approval: limit.approval,
+					};
+					break;
+				}
+				case "budget": {
+					const remaining = limit.availableBudget ?? limit.totalBudget ?? 0;
+					const actual = limit.subject.type === "cost-center"
+						? lineTotalByCostCenter.get(limit.subject.costCenterId) ?? 0
+						: netTotal;
+					if (limit.subject.type === "cost-center" && actual === 0) {
+						break; // cost center not used in this cart
+					}
+					entry = {
+						limitId: limit.id, type: limit.type, label: limit.label,
+						status: actual > remaining ? "exceeded" : "within",
+						threshold: remaining, actual,
+						...(actual > remaining ? { exceededBy: r2(actual - remaining) } : {}),
+						approval: limit.approval,
+					};
+					break;
+				}
+				case "unit-price": {
+					const threshold = limit.maxAmount ?? 0;
+					entry = {
+						limitId: limit.id, type: limit.type, label: limit.label,
+						status: maxUnitPrice > threshold ? "exceeded" : "within",
+						threshold, actual: maxUnitPrice,
+						...(maxUnitPrice > threshold ? { exceededBy: r2(maxUnitPrice - threshold) } : {}),
+						approval: limit.approval,
+					};
+					break;
+				}
+				case "non-catalog": {
+					if (hasNonCatalog) {
+						entry = {
+							limitId: limit.id, type: limit.type, label: limit.label,
+							status: "exceeded",
+							approval: limit.approval,
+						};
+					}
+					break;
+				}
+			}
+
+			if (entry) {
+				triggered.push(entry);
+			}
+		}
+
+		return triggered;
+	}
+
+	private async loadStock(): Promise<Map<string, number>> {
+		const entries = await readCoverDataJson<ProductListEntry[]>("product-list.json");
+		const map = new Map<string, number>();
+		for (const entry of entries) {
+			const id = entry.product?.[0]?.id;
+			if (id !== undefined && id !== null) {
+				map.set(String(id), entry.stocks?.[0]?.quantity ?? 0);
+			}
+		}
+		return map;
+	}
+}

package/server/services/MockMarketService.ts

@@ -0,0 +1,18 @@
+import type { ShopMarket } from "../../app/interfaces/market";
+import type { IMarketService } from "../interfaces/market";
+
+/**
+ * Bundled demo markets — mirrors the live markets app payload shape so the
+ * selector behaves identically in mock and live mode.
+ */
+export class MockMarketService implements IMarketService {
+	private readonly dataKey: string;
+
+	constructor(dataKey: string) {
+		this.dataKey = dataKey;
+	}
+
+	async listMarkets(): Promise<ShopMarket[]> {
+		return readCoverDataJson<ShopMarket[]>(this.dataKey);
+	}
+}

package/server/services/SdkAccountService.ts

@@ -0,0 +1,56 @@
+import type { H3Event } from "h3";
+
+import type { StoredSession } from "../../app/interfaces/auth";
+import type { AccountUser, IAccountService } from "../interfaces/account";
+
+function createInitials(name: string): string {
+	const parts = name
+		.trim()
+		.split(/\s+/)
+		.filter(Boolean);
+	if (parts.length === 0) {
+		return "";
+	}
+	return parts
+		.slice(0, 2)
+		.map(part => part[0]?.toUpperCase() ?? "")
+		.join("");
+}
+
+/**
+ * Live identity implementation backed by the revenexx web SDK.
+ * Resolves the current user from the request's session cookie and the
+ * platform account endpoint. Requires the NUXT_WEB_SDK_* runtime config.
+ * Register via app.config → accountService: "sdk".
+ */
+export class SdkAccountService implements IAccountService {
+	async getUser(event?: H3Event): Promise<AccountUser> {
+		if (!event) {
+			throw createError({ statusCode: 500, statusMessage: "SdkAccountService requires the request event" });
+		}
+
+		const rawSession = getCookie(event, SESSION_COOKIE_NAME);
+		if (!rawSession) {
+			throw createError({ statusCode: 401, statusMessage: "Unauthorized" });
+		}
+
+		let session: StoredSession;
+		try {
+			session = JSON.parse(rawSession) as StoredSession;
+		}
+		catch {
+			throw createError({ statusCode: 401, statusMessage: "Unauthorized" });
+		}
+		if (!session.fallbackCookie) {
+			throw createError({ statusCode: 401, statusMessage: "Unauthorized" });
+		}
+
+		const accountUser = await useAuthenticatedAccount(session.fallbackCookie).accountGet();
+		return {
+			id: accountUser.$id,
+			name: accountUser.name,
+			email: accountUser.email,
+			initials: createInitials(accountUser.name),
+		};
+	}
+}

package/server/services/SdkAuthService.ts

@@ -0,0 +1,83 @@
+import type { H3Event } from "h3";
+
+import type { AuthUser, StoredSession } from "../../app/interfaces/auth";
+import type { AuthLoginResult, IAuthService } from "../interfaces/auth";
+
+/**
+ * Live authentication via the revenexx web SDK. Session state is carried in
+ * the same cookie as the mock implementation (with fallbackCookie set), so
+ * the client-side flow is identical. Requires NUXT_WEB_SDK_* runtime config.
+ */
+export class SdkAuthService implements IAuthService {
+	async login(event: H3Event, email: string, password: string): Promise<AuthLoginResult> {
+		const { result: session, fallbackCookie } = await withCookieCapture(
+			() => useShopSdkAccount().accountCreateEmailPasswordSession({ email, password }),
+		);
+
+		const user = await useAuthenticatedAccount(fallbackCookie).accountGet();
+
+		const storedSession: StoredSession = {
+			id: session.$id,
+			expire: session.expire,
+			fallbackCookie,
+		};
+		setCookie(event, SESSION_COOKIE_NAME, JSON.stringify(storedSession), sessionCookieOptions(session.expire));
+
+		return {
+			user: { $id: user.$id, name: user.name, email: user.email },
+			session: { id: session.$id, expire: session.expire },
+		};
+	}
+
+	async me(event: H3Event): Promise<AuthUser | null> {
+		const raw = getCookie(event, SESSION_COOKIE_NAME);
+		if (!raw) {
+			return null;
+		}
+
+		let parsed: StoredSession;
+		try {
+			parsed = JSON.parse(raw) as StoredSession;
+		}
+		catch (err) {
+			getLogService().error("Failed to parse session cookie", toErrorContext(err));
+			deleteCookie(event, SESSION_COOKIE_NAME, sessionCookieOptions());
+			return null;
+		}
+
+		if (!parsed.fallbackCookie) {
+			deleteCookie(event, SESSION_COOKIE_NAME, sessionCookieOptions());
+			return null;
+		}
+
+		try {
+			const user = await useAuthenticatedAccount(parsed.fallbackCookie).accountGet();
+			return { $id: user.$id, name: user.name, email: user.email };
+		}
+		catch (err) {
+			if (!isSdkUserError(err)) {
+				getLogService().error("SDK request failed: me/accountGet", sdkErrorContext(err));
+			}
+			deleteCookie(event, SESSION_COOKIE_NAME, sessionCookieOptions());
+			return null;
+		}
+	}
+
+	async logout(event: H3Event): Promise<void> {
+		const raw = getCookie(event, SESSION_COOKIE_NAME);
+		if (raw) {
+			try {
+				const parsed = JSON.parse(raw) as StoredSession;
+				if (parsed.fallbackCookie) {
+					const sessionId = parsed.id || "current";
+					await useAuthenticatedAccount(parsed.fallbackCookie).accountDeleteSession({ sessionId });
+				}
+			}
+			catch (err) {
+				getLogService().error("SDK request failed: logout", sdkErrorContext(err));
+				// always clear the cookie regardless of SDK result
+			}
+		}
+		deleteCookie(event, SESSION_COOKIE_NAME, sessionCookieOptions());
+	}
+}