@revenexx/cover 0.1.0

package/app/composables/useAccountAddresses.ts

@@ -0,0 +1,116 @@
+import { accountApi } from "../api/account";
+import type { AccountAddress, AccountAddressFormState, AccountAddressListResponse } from "../interfaces/account/address-list";
+
+export const useAccountAddresses = () => {
+	const { data, status, error, refresh } = useFetch<AccountAddressListResponse>(
+		accountApi.addresses(),
+		{
+			key: "account-addresses",
+			default: () => ({ addresses: [] as AccountAddress[] }),
+		},
+	);
+
+	const addresses = computed(() => data.value.addresses);
+
+	async function updateAddress(
+		id: string,
+		formState: AccountAddressFormState,
+	): Promise<AccountAddress> {
+		const updated = await $fetch<AccountAddress>(accountApi.addressUpdate(id), {
+			method: "PUT",
+			body: formState,
+		});
+
+		data.value = {
+			...data.value,
+			addresses: data.value.addresses.map((a) => {
+				if (a.id === id) {
+					return updated;
+				}
+				if (updated.isDefault && a.type === updated.type) {
+					return { ...a, isDefault: false };
+				}
+				return a;
+			}),
+		};
+
+		return updated;
+	}
+
+	async function createAddress(formState: AccountAddressFormState): Promise<AccountAddress> {
+		const created = await $fetch<AccountAddress>(accountApi.addressCreate(), {
+			method: "POST",
+			body: formState,
+		});
+		if (created.isDefault) {
+			data.value = {
+				...data.value,
+				addresses: [
+					...data.value.addresses.map(a =>
+						a.type === created.type ? { ...a, isDefault: false } : a,
+					),
+					created,
+				],
+			};
+		}
+		else {
+			data.value = { ...data.value, addresses: [...data.value.addresses, created] };
+		}
+		return created;
+	}
+
+	async function deleteAddress(id: string): Promise<void> {
+		const result = await $fetch<AccountAddressListResponse>(accountApi.addressDelete(id), {
+			method: "DELETE",
+		});
+		data.value = { ...data.value, addresses: result.addresses };
+	}
+
+	async function autoFixDefaults(list: AccountAddress[]) {
+		const byType: Record<string, AccountAddress[]> = {};
+		for (const a of list) {
+			(byType[a.type] ??= []).push(a);
+		}
+		for (const group of Object.values(byType)) {
+			if (group.length === 1 && !group[0].isDefault) {
+				const a = group[0];
+				await updateAddress(a.id, {
+					company: a.company,
+					label: a.label,
+					firstName: a.firstName,
+					lastName: a.lastName,
+					street: a.street,
+					streetNumber: a.streetNumber,
+					city: a.city,
+					zip: a.zip,
+					country: a.country,
+					type: a.type,
+					isDefault: true,
+				});
+			}
+		}
+	}
+
+	let fixApplied = false;
+	watch(
+		addresses,
+		async (list) => {
+			if (list.length === 0 || fixApplied) {
+				return;
+			}
+			fixApplied = true;
+			await autoFixDefaults(list);
+		},
+		{ immediate: true },
+	);
+
+	return {
+		addresses,
+		status,
+		error,
+		refresh,
+		updateAddress,
+		createAddress,
+		deleteAddress,
+	};
+};

package/app/composables/useAccountOrders.ts

@@ -0,0 +1,18 @@
+import { accountApi } from "../api/account";
+import type { AccountOrder, AccountOrderListResponse } from "../interfaces/account/order-list";
+
+export const useAccountOrders = () => {
+	const { data, status, error, refresh } = useFetch<AccountOrderListResponse>(accountApi.orders(), {
+		key: "account-orders",
+		default: () => ({ orders: [] as AccountOrder[] }),
+	});
+
+	const orders = computed(() => data.value.orders);
+
+	return {
+		orders,
+		status,
+		error,
+		refresh,
+	};
+};

package/app/composables/useAppUrl.ts

@@ -0,0 +1,38 @@
+/**
+ * Locale-aware URL helper. Converts slash-prefixed paths to Nuxt route names
+ * and delegates to useLocalePath() so all navigation carries the current locale.
+ *
+ * Path → route name mapping follows Nuxt 4 file-based routing:
+ *   /               → index
+ *   /cart           → cart
+ *   /checkout       → checkout
+ *   /checkout/...   → checkout-...
+ *
+ * useLocalePath() from @nuxtjs/i18n v10 requires route names (not path strings);
+ * passing paths is documented as unsupported and breaks with prefix strategies.
+ */
+export const useAppUrl = () => {
+	const localePath = useLocalePath();
+	const route = useRoute();
+
+	function pathToRouteName(path: string): string {
+		if (path === "/") {
+			return "index";
+		}
+		return path.replace(/^\//, "").replace(/\//g, "-");
+	}
+
+	function to(path: string, query?: Record<string, string>): string {
+		const name = pathToRouteName(path);
+		if (query) {
+			return localePath({ name, query });
+		}
+		return localePath(name);
+	}
+
+	const isCartOrCheckoutPage = computed(() =>
+		/\/(cart|checkout)(\/|$)/.test(route.path),
+	);
+
+	return { to, isCartOrCheckoutPage };
+};

package/app/composables/useAuthStore.ts

@@ -0,0 +1,202 @@
+import { defineStore } from "pinia";
+
+import type { AuthUser, LoginInput, RegisterInput, StoredSession } from "../interfaces/auth";
+
+const WAS_AUTHENTICATED_KEY = "cover-was-authenticated";
+
+function mapAuthError(err: unknown, context: "login" | "recovery" = "login"): string {
+	const type = (err as { data?: { data?: { type?: string } } })?.data?.data?.type;
+	if (typeof type === "string") {
+		switch (type) {
+			case "service_unavailable":
+				return "auth.errors.serviceUnavailable";
+			case "user_invalid_credentials":
+			case "user_not_found":
+				return context === "recovery"
+					? "auth.recovery.errors.userNotFound"
+					: "auth.login.errors.invalidCredentials";
+			case "user_blocked":
+				return "auth.login.errors.accountBlocked";
+			case "general_rate_limit_exceeded":
+				return context === "recovery"
+					? "auth.recovery.errors.rateLimited"
+					: "auth.login.errors.rateLimited";
+			case "user_session_already_exists":
+				return "auth.login.errors.sessionExists";
+			case "user_invalid_token":
+			case "general_argument_invalid":
+				return "auth.recovery.errors.invalidToken";
+			case "password_recently_used":
+				return "auth.recovery.errors.passwordRecentlyUsed";
+		}
+		return context === "recovery"
+			? "auth.recovery.errors.unknown"
+			: "auth.login.errors.unknown";
+	}
+	return context === "recovery"
+		? "auth.recovery.errors.network"
+		: "auth.login.errors.network";
+}
+
+export const useAuthStore = defineStore("auth", () => {
+	const user = ref<AuthUser | null>(null);
+	const session = ref<StoredSession | null>(null);
+
+	const isLoggedIn = computed(() => user.value !== null);
+
+	const loading = ref(false);
+	const error = ref<string | null>(null);
+
+	function markAuthenticated() {
+		localStorage.setItem(WAS_AUTHENTICATED_KEY, "1");
+	}
+
+	async function handleAuthExpiry() {
+		if (!localStorage.getItem(WAS_AUTHENTICATED_KEY)) {
+			return;
+		}
+		localStorage.removeItem(WAS_AUTHENTICATED_KEY);
+		const cart = useCartStore();
+		if (cart.liveCarts) {
+			// The customer's carts live server-side — only the local view resets.
+			await cart.onAuthLogout();
+			return;
+		}
+		cart.clearCart();
+		await cart.clearServerCart();
+	}
+
+	const register = async ({ email, password, name, profile }: RegisterInput) => {
+		loading.value = true;
+		error.value = null;
+		try {
+			const created = await $fetch<AuthUser>("/api/auth/register", {
+				method: "POST",
+				body: { email, password, name, profile },
+			});
+			user.value = created;
+			return created;
+		}
+		catch (err) {
+			error.value = mapAuthError(err);
+			throw err;
+		}
+		finally {
+			loading.value = false;
+		}
+	};
+
+	const login = async ({ email, password }: LoginInput) => {
+		loading.value = true;
+		error.value = null;
+		try {
+			const result = await $fetch<{ user: AuthUser; session: StoredSession }>("/api/auth/login", {
+				method: "POST",
+				body: { email, password },
+			});
+			user.value = result.user;
+			session.value = result.session;
+			markAuthenticated();
+			// Live carts: the BFF claimed/merged the session carts on login —
+			// adopt the merged server state into the local cart.
+			void useCartStore().onAuthLogin();
+			return result.session;
+		}
+		catch (err) {
+			error.value = mapAuthError(err);
+			throw err;
+		}
+		finally {
+			loading.value = false;
+		}
+	};
+
+	const logout = async () => {
+		loading.value = true;
+		error.value = null;
+		try {
+			await $fetch("/api/auth/logout", { method: "POST" });
+		}
+		catch (err) {
+			error.value = mapAuthError(err);
+		}
+		finally {
+			localStorage.removeItem(WAS_AUTHENTICATED_KEY);
+			const cart = useCartStore();
+			if (cart.liveCarts) {
+				// The customer's carts stay in the carts app — reset the view.
+				void cart.onAuthLogout();
+			}
+			else {
+				cart.clearCart();
+				void cart.clearServerCart();
+			}
+			loading.value = false;
+			session.value = null;
+			user.value = null;
+		}
+	};
+
+	const requestRecovery = async (email: string, url: string) => {
+		loading.value = true;
+		error.value = null;
+		try {
+			return await $fetch("/api/auth/recovery", {
+				method: "POST",
+				body: { email, url },
+			});
+		}
+		catch (err) {
+			error.value = mapAuthError(err, "recovery");
+			throw err;
+		}
+		finally {
+			loading.value = false;
+		}
+	};
+
+	const confirmRecovery = async (userId: string, secret: string, password: string) => {
+		loading.value = true;
+		error.value = null;
+		try {
+			return await $fetch("/api/auth/recovery", {
+				method: "PUT",
+				body: { userId, secret, password },
+			});
+		}
+		catch (err) {
+			error.value = mapAuthError(err, "recovery");
+			throw err;
+		}
+		finally {
+			loading.value = false;
+		}
+	};
+
+	const init = async (): Promise<void> => {
+		try {
+			const me = await $fetch<AuthUser | null>("/api/auth/me");
+			if (me) {
+				user.value = me;
+				markAuthenticated();
+			}
+			else {
+				user.value = null;
+				session.value = null;
+				await handleAuthExpiry();
+			}
+		}
+		catch {
+			user.value = null;
+			session.value = null;
+			await handleAuthExpiry();
+		}
+	};
+
+	return {
+		user, session, isLoggedIn, loading, error,
+		register, login, logout,
+		requestRecovery, confirmRecovery,
+		init,
+	};
+});

package/app/composables/useB2BContext.ts

@@ -0,0 +1,23 @@
+import type { B2BContext } from "../interfaces/b2b";
+
+/**
+ * The current user's B2B context — organization settings, cost centers,
+ * spending limits and workflow memberships. Fetched once and shared;
+ * call `refresh()` after auth changes.
+ */
+export function useB2BContext() {
+	const { data: context, refresh, status } = useFetch<B2BContext>("/api/account/context", {
+		key: "b2b-context",
+	});
+
+	const settings = computed(() => context.value?.settings ?? null);
+	const costCenters = computed(() => context.value?.costCenters ?? []);
+	const role = computed(() => context.value?.role ?? null);
+	const workflows = computed(() => context.value?.workflows ?? []);
+
+	const costCenterById = computed(() =>
+		new Map(costCenters.value.map(cc => [cc.id, cc])),
+	);
+
+	return { context, settings, costCenters, costCenterById, role, workflows, refresh, status };
+}

package/app/composables/useCartActions.ts

@@ -0,0 +1,25 @@
+export type CartActionType = "cost-center" | "texts" | "save" | "export";
+
+interface CartActionState {
+	type: CartActionType | null;
+	lineKeys: string[];
+}
+
+/**
+ * Shared state for the cart position/bulk action modals. The modals are
+ * mounted once in the cart view; positions and the bulk bar open them by
+ * setting the action with the affected line keys.
+ */
+export function useCartActions() {
+	const action = useState<CartActionState>("cart-action", () => ({ type: null, lineKeys: [] }));
+
+	function open(type: CartActionType, lineKeys: string[]): void {
+		action.value = { type, lineKeys };
+	}
+
+	function close(): void {
+		action.value = { type: null, lineKeys: [] };
+	}
+
+	return { action, open, close };
+}

package/app/composables/useCartCalculation.ts

@@ -0,0 +1,90 @@
+import type { CartCalculation, CalculatedCartLine } from "../interfaces/cart-calculation";
+
+/**
+ * Shared cart calculation state. Exactly one component per page (the cart
+ * view or the checkout summary) orchestrates the recalculation by passing
+ * `orchestrate: true`; every other consumer just reads the shared state.
+ *
+ * Lines are matched to cart items BY INDEX — the same article may sit on
+ * several positions, so ids are not unique per line.
+ */
+export function useCartCalculation(options?: {
+	orchestrate?: boolean;
+	deliveryMethod?: Ref<string | undefined>;
+}) {
+	const cart = useCartStore();
+	const { locale } = useI18n();
+
+	const calculation = useState<CartCalculation | null>("cart-calculation", () => null);
+	const pending = useState<boolean>("cart-calculation-pending", () => false);
+
+	async function refresh(): Promise<void> {
+		if (cart.items.length === 0) {
+			calculation.value = null;
+			return;
+		}
+		pending.value = true;
+		try {
+			calculation.value = await $fetch<CartCalculation>("/api/cart/calculate", {
+				method: "POST",
+				headers: { "x-locale": locale.value },
+				body: {
+					items: cart.items,
+					...(options?.deliveryMethod?.value
+						? { deliveryMethod: options.deliveryMethod.value }
+						: {}),
+				},
+			});
+		}
+		catch {
+			// keep the previous calculation; the cart stays usable
+		}
+		finally {
+			pending.value = false;
+		}
+	}
+
+	if (options?.orchestrate && import.meta.client) {
+		let timer: ReturnType<typeof setTimeout> | null = null;
+		const debouncedRefresh = () => {
+			if (timer) {
+				clearTimeout(timer);
+			}
+			timer = setTimeout(() => {
+				timer = null;
+				void refresh();
+			}, 300);
+		};
+
+		watch(() => cart.items, debouncedRefresh, { deep: true, immediate: true });
+		watch(locale, debouncedRefresh);
+		if (options.deliveryMethod) {
+			watch(options.deliveryMethod, debouncedRefresh);
+		}
+
+		onScopeDispose(() => {
+			if (timer) {
+				clearTimeout(timer);
+			}
+		});
+	}
+
+	/** Calculated line for the cart item at the given index. */
+	const lineAt = (index: number): CalculatedCartLine | null =>
+		calculation.value?.lines[index] ?? null;
+
+	/** lineKey → calculated line, zipped by index. */
+	const linesByKey = computed(() => {
+		const map = new Map<string, CalculatedCartLine>();
+		const lines = calculation.value?.lines ?? [];
+		cart.items.forEach((item, index) => {
+			const line = lines[index];
+			if (line) {
+				map.set(cart.keyOf(item), line);
+			}
+		});
+		return map;
+	});
+
+	return { calculation, pending, refresh, lineAt, linesByKey };
+}

package/app/composables/useCartSelection.ts

@@ -0,0 +1,46 @@
+/**
+ * Multi-selection state for cart positions (by lineKey). Drives the
+ * three-state header checkbox and the bulk action bar.
+ */
+export function useCartSelection() {
+	const cart = useCartStore();
+	const selected = useState<string[]>("cart-selection", () => []);
+
+	const selectedSet = computed(() => new Set(selected.value));
+
+	const allKeys = computed(() => cart.items.map(item => cart.keyOf(item)));
+
+	const allSelected = computed(() =>
+		allKeys.value.length > 0 && allKeys.value.every(key => selectedSet.value.has(key)),
+	);
+	const someSelected = computed(() => selected.value.length > 0 && !allSelected.value);
+
+	function isSelected(lineKey: string): boolean {
+		return selectedSet.value.has(lineKey);
+	}
+
+	function toggle(lineKey: string): void {
+		selected.value = isSelected(lineKey)
+			? selected.value.filter(key => key !== lineKey)
+			: [...selected.value, lineKey];
+	}
+
+	/** Header checkbox: unchecked/intermediate → select all; checked → none. */
+	function toggleAll(): void {
+		selected.value = allSelected.value ? [] : [...allKeys.value];
+	}
+
+	function clear(): void {
+		selected.value = [];
+	}
+
+	/** Drops selections whose positions left the cart. */
+	function prune(): void {
+		const keys = new Set(allKeys.value);
+		if (selected.value.some(key => !keys.has(key))) {
+			selected.value = selected.value.filter(key => keys.has(key));
+		}
+	}
+
+	return { selected, allSelected, someSelected, isSelected, toggle, toggleAll, clear, prune };
+}