@revenexx/cover 0.1.9 → 0.1.10

package/app/app.config.ts

@@ -12,6 +12,7 @@ import { DEFAULT_ICON_WEIGHT, nuxtUiIcons } from "./config/icons";
 export default defineAppConfig({
 	schemaService: "local-file",
 	accountService: "mock",
+	addressService: "mock",
 	authService: "mock",
 	productService: "mock",
 	categoryService: "mock",

package/app/components/checkout/form/CheckoutSchemaForm.vue

@@ -21,7 +21,11 @@ const { locale } = useI18n();
 
 const formId = useId();
 
-const { data: schema, pending } = await useAsyncData(
+// No top-level await: async setup would turn this into an async component,
+// and the parent's template ref then binds a wrapper WITHOUT the exposed
+// submit() — the modal's save button silently did nothing. The template
+// renders the pending state instead.
+const { data: schema, pending } = useAsyncData(
 	() => `checkout-schema-${props.schemaKey}-${locale.value}`,
 	() => fetchSchemaByKey(props.schemaKey) as Promise<FormKitSchemaDefinition>,
 	{ watch: [() => props.schemaKey, locale] },

package/app/components/checkout/onepage/CheckoutAddressPickerModal.vue

@@ -90,7 +90,7 @@ function splitStreet(street: string): { street: string; streetNumber: string } {
 }
 
 async function saveNewAddress() {
-	if (!formRenderer.value) {
+	if (typeof formRenderer.value?.submit !== "function") {
 		return;
 	}
 	const values = await formRenderer.value.submit();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@revenexx/cover",
-  "version": "0.1.9",
+  "version": "0.1.10",
   "description": "Cover \u2014 revenexx design system for Nuxt. Distributed as a Nuxt layer: generic UI components, theming tokens and stores shared by the demo shop, custom storefronts and the Blokkli theme.",
   "type": "module",
   "main": "./nuxt.config.ts",

package/server/api/account/address/[id].delete.ts

@@ -1,9 +1,4 @@
-import type { AccountAddress, AccountAddressListResponse } from "../../../../app/interfaces/account/address-list";
-
-interface AddressListRaw {
-	userId: string;
-	addresses: AccountAddress[];
-}
+import type { AccountAddressListResponse } from "../../../../app/interfaces/account/address-list";
 
 export default defineEventHandler(async (event): Promise<AccountAddressListResponse> => {
 	const id = getRouterParam(event, "id");
@@ -11,41 +6,5 @@ export default defineEventHandler(async (event): Promise<AccountAddressListRespo
 		throw createError({ statusCode: 400, statusMessage: "Missing address id" });
 	}
 
-	let data: AddressListRaw;
-	try {
-		data = await readCoverMutableJson<AddressListRaw>("account/address-list.json");
-	}
-	catch {
-		throw createError({ statusCode: 500, statusMessage: "Address store unavailable" });
-	}
-
-	const address = data.addresses.find(a => a.id === id);
-	if (!address) {
-		throw createError({ statusCode: 404, statusMessage: "Address not found" });
-	}
-
-	const billingCount = data.addresses.filter(a => a.type === "billing").length;
-	if (address.type === "billing" && billingCount <= 1) {
-		throw createError({ statusCode: 400, statusMessage: "Cannot delete the last billing address" });
-	}
-
-	let remaining = data.addresses.filter(a => a.id !== id);
-
-	// If deletion leaves no billing address, promote first shipping to billing + isDefault
-	const hasBilling = remaining.some(a => a.type === "billing");
-	if (!hasBilling && remaining.length > 0) {
-		const firstShippingIdx = remaining.findIndex(a => a.type === "shipping");
-		if (firstShippingIdx !== -1) {
-			remaining = remaining.map((a, i) => {
-				if (i === firstShippingIdx) {
-					return { ...a, type: "billing" as const, isDefault: true };
-				}
-				return a;
-			});
-		}
-	}
-
-	await writeCoverMutableJson("account/address-list.json", { ...data, addresses: remaining });
-
-	return { addresses: remaining };
+	return { addresses: await getAddressBookService(event).remove(event, id) };
 });

package/server/api/account/address/[id].put.ts

@@ -1,9 +1,8 @@
-import type { AccountAddress, AccountAddressType } from "../../../../app/interfaces/account/address-list";
-
-interface AddressListRaw {
-	userId: string;
-	addresses: AccountAddress[];
-}
+import type {
+	AccountAddress,
+	AccountAddressFormState,
+	AccountAddressType,
+} from "../../../../app/interfaces/account/address-list";
 
 interface AddressUpdateBody {
 	readonly company?: unknown;
@@ -34,50 +33,23 @@ export default defineEventHandler(async (event): Promise<AccountAddress> => {
 
 	const body = await readBody<AddressUpdateBody>(event);
 
-	const company = typeof body.company === "string" ? body.company.trim() : "";
-	const label = requireString(body.label, "label");
-	const firstName = requireString(body.firstName, "firstName");
-	const lastName = requireString(body.lastName, "lastName");
-	const street = requireString(body.street, "street");
-	const streetNumber = requireString(body.streetNumber, "streetNumber");
-	const city = requireString(body.city, "city");
-	const zip = requireString(body.zip, "zip");
-	const country = requireString(body.country, "country");
-
 	if (body.type !== "billing" && body.type !== "shipping") {
 		throw createError({ statusCode: 422, statusMessage: "Invalid address type" });
 	}
-	const type = body.type as AccountAddressType;
-	const isDefault = body.isDefault === true;
-
-	let data: AddressListRaw;
-	try {
-		data = await readCoverMutableJson<AddressListRaw>("account/address-list.json");
-	}
-	catch {
-		throw createError({ statusCode: 500, statusMessage: "Address store unavailable" });
-	}
-
-	const index = data.addresses.findIndex(a => a.id === id);
-	if (index === -1) {
-		throw createError({ statusCode: 404, statusMessage: "Address not found" });
-	}
-
-	// When setting isDefault, clear it from other addresses of the same type
-	const updatedAddresses: AccountAddress[] = data.addresses.map((a, i) => {
-		if (i === index) {
-			return {
-				...a, company, label, firstName, lastName,
-				street, streetNumber, city, zip, country, type, isDefault,
-			};
-		}
-		if (isDefault && a.type === type) {
-			return { ...a, isDefault: false };
-		}
-		return a;
-	});
-
-	await writeCoverMutableJson("account/address-list.json", { ...data, addresses: updatedAddresses });
 
-	return updatedAddresses[index]!;
+	const input: AccountAddressFormState = {
+		company: typeof body.company === "string" ? body.company.trim() : "",
+		label: requireString(body.label, "label"),
+		firstName: requireString(body.firstName, "firstName"),
+		lastName: requireString(body.lastName, "lastName"),
+		street: requireString(body.street, "street"),
+		streetNumber: requireString(body.streetNumber, "streetNumber"),
+		city: requireString(body.city, "city"),
+		zip: requireString(body.zip, "zip"),
+		country: requireString(body.country, "country"),
+		type: body.type as AccountAddressType,
+		isDefault: body.isDefault === true,
+	};
+
+	return getAddressBookService(event).update(event, id, input);
 });

package/server/api/account/address/index.post.ts

@@ -3,11 +3,6 @@ import type {
 	AccountAddressFormState,
 } from "../../../../app/interfaces/account/address-list";
 
-interface AddressListRaw {
-	userId: string;
-	addresses: AccountAddress[];
-}
-
 export default defineEventHandler(async (event): Promise<AccountAddress> => {
 	const body = await readBody<AccountAddressFormState>(event);
 
@@ -19,42 +14,9 @@ export default defineEventHandler(async (event): Promise<AccountAddress> => {
 			throw createError({ statusCode: 400, statusMessage: `Missing required field: ${field}` });
 		}
 	}
-
-	let data: AddressListRaw;
-	try {
-		data = await readCoverMutableJson<AddressListRaw>("account/address-list.json");
-	}
-	catch {
-		throw createError({ statusCode: 500, statusMessage: "Address store unavailable" });
-	}
-
-	const sameType = data.addresses.filter(a => a.type === body.type);
-	const isDefault = body.isDefault || sameType.length === 0;
-
-	const newAddress: AccountAddress = {
-		id: crypto.randomUUID(),
-		company: body.company ?? "",
-		label: body.label.trim(),
-		firstName: body.firstName.trim(),
-		lastName: body.lastName.trim(),
-		street: body.street.trim(),
-		streetNumber: body.streetNumber.trim(),
-		city: body.city.trim(),
-		zip: body.zip.trim(),
-		country: body.country,
-		type: body.type,
-		isDefault,
-	};
-
-	let addresses = [...data.addresses];
-	if (isDefault) {
-		addresses = addresses.map(a =>
-			a.type === newAddress.type ? { ...a, isDefault: false } : a,
-		);
+	if (body.type !== "billing" && body.type !== "shipping") {
+		throw createError({ statusCode: 422, statusMessage: "Invalid address type" });
 	}
-	addresses.push(newAddress);
-
-	await writeCoverMutableJson("account/address-list.json", { ...data, addresses });
 
-	return newAddress;
+	return getAddressBookService(event).create(event, body);
 });

package/server/api/account/addresses.get.ts

@@ -1,25 +1,5 @@
+import type { AccountAddressListResponse } from "../../../app/interfaces/account/address-list";
 
-interface AccountAddress {
-	readonly id: string;
-	readonly company: string;
-	readonly label: string;
-	readonly firstName: string;
-	readonly lastName: string;
-	readonly street: string;
-	readonly streetNumber: string;
-	readonly city: string;
-	readonly zip: string;
-	readonly country: string;
-	readonly isDefault: boolean;
-	readonly type: "billing" | "shipping";
-}
-
-interface AccountAddressListResponse {
-	readonly addresses: AccountAddress[];
-}
-
-export default defineEventHandler((): AccountAddressListResponse => {
-
-
-	return readCoverMutableJson<AccountAddressListResponse>("account/address-list.json");
+export default defineEventHandler(async (event): Promise<AccountAddressListResponse> => {
+	return { addresses: await getAddressBookService(event).list(event) };
 });

package/server/api/checkout/profile.get.ts

@@ -12,7 +12,7 @@ export default defineEventHandler(async (event) => {
 	}
 
 	try {
-		return await getCheckoutProfileService().getProfile(user?.$id ?? null);
+		return await getCheckoutProfileService().getProfile(event, user?.$id ?? null);
 	}
 	catch (err) {
 		getLogService().error("Service error: checkout/profile", toErrorContext(err));

package/server/api/payment/methods.post.ts

@@ -28,7 +28,7 @@ export default defineEventHandler(async (event) => {
 
 	if (resolvePaymentServiceKey(event) !== "api") {
 		const user = await getAuthService(event).me(event);
-		const profile = await getCheckoutProfileService().getProfile(user?.$id ?? null);
+		const profile = await getCheckoutProfileService().getProfile(event, user?.$id ?? null);
 		return {
 			managed: false,
 			methods: profile.availablePaymentMethods,

package/server/api/shipping/rates.post.ts

@@ -35,7 +35,7 @@ export default defineEventHandler(async (event) => {
 
 	if (resolveShippingServiceKey(event) !== "api") {
 		const user = await getAuthService(event).me(event);
-		const profile = await getCheckoutProfileService().getProfile(user?.$id ?? null);
+		const profile = await getCheckoutProfileService().getProfile(event, user?.$id ?? null);
 		return {
 			managed: false,
 			methods: profile.availableDeliveryMethods,

package/server/interfaces/addressBook.ts

@@ -0,0 +1,19 @@
+import type { H3Event } from "h3";
+
+import type { AccountAddress, AccountAddressFormState } from "../../app/interfaces/account/address-list";
+
+/**
+ * Service contract for the customer's address book — consumed by the
+ * account address pages AND the checkout profile, so both surfaces always
+ * read and write the same store.
+ * - "mock" — mutable demo JSON (account/address-list.json)
+ * - "api"  — contact addresses in the customers app via the public API
+ * Register the active implementation via app.config → addressService.
+ */
+export interface IAddressBookService {
+	list(event: H3Event): Promise<AccountAddress[]>;
+	create(event: H3Event, input: AccountAddressFormState): Promise<AccountAddress>;
+	update(event: H3Event, id: string, input: AccountAddressFormState): Promise<AccountAddress>;
+	/** Returns the remaining addresses after deletion. */
+	remove(event: H3Event, id: string): Promise<AccountAddress[]>;
+}

package/server/interfaces/checkoutProfile.ts

@@ -1,5 +1,12 @@
+import type { H3Event } from "h3";
+
 import type { CheckoutProfile } from "../../app/interfaces/checkout";
 
 export interface ICheckoutProfileService {
-	getProfile(userId: string | null): Promise<CheckoutProfile>;
+	/**
+	 * The signed-in user's checkout profile. Addresses come from the
+	 * address book service (mock or live per `addressService`); the event
+	 * carries the session and the per-request service-mode resolution.
+	 */
+	getProfile(event: H3Event, userId: string | null): Promise<CheckoutProfile>;
 }

package/server/services/ApiAddressBookService.ts

@@ -0,0 +1,155 @@
+import type { H3Event } from "h3";
+import { AddressType } from "@revenexx/sdk";
+
+import type { AccountAddress, AccountAddressFormState } from "../../app/interfaces/account/address-list";
+
+import type { IAddressBookService } from "../interfaces/addressBook";
+
+/** Raw address row from the customers app (snake_case API shape). */
+interface ApiAddressRow {
+	id: string;
+	organization_id: string | null;
+	contact_id: string | null;
+	type: "billing" | "shipping";
+	company: string | null;
+	name: string | null;
+	street: string;
+	street2: string | null;
+	zip: string;
+	city: string;
+	region: string | null;
+	country: string;
+	phone: string | null;
+	is_default: boolean;
+}
+
+/** "Teststraße 1a" → { street: "Teststraße", streetNumber: "1a" }. */
+function splitStreet(street: string): { street: string; streetNumber: string } {
+	const match = street.trim().match(/^(.*?)\s+(\S*\d\S*)$/);
+	return match
+		? { street: match[1] ?? street, streetNumber: match[2] ?? "" }
+		: { street: street.trim(), streetNumber: "" };
+}
+
+function toAccountAddress(row: ApiAddressRow): AccountAddress {
+	const name = (row.name ?? "").trim();
+	const [firstName, ...rest] = name.split(/\s+/).filter(Boolean);
+	const streetParts = splitStreet(row.street);
+	return {
+		id: row.id,
+		company: row.company ?? "",
+		label: row.company || name || streetParts.street,
+		firstName: firstName ?? "",
+		lastName: rest.join(" "),
+		street: streetParts.street,
+		streetNumber: streetParts.streetNumber,
+		city: row.city,
+		zip: row.zip,
+		country: row.country,
+		isDefault: row.is_default,
+		type: row.type === "billing" ? "billing" : "shipping",
+	};
+}
+
+/**
+ * Live address book: the signed-in contact's addresses in the customers
+ * app. The contact comes from the session cookie; guests have no address
+ * book. The customers schema requires ISO 3166-1 alpha-2 countries.
+ */
+export class ApiAddressBookService implements IAddressBookService {
+	private contactRef(event: H3Event): { contact_id?: string; organization_id?: string } {
+		return sessionOrderRefs(event);
+	}
+
+	private requireContact(event: H3Event): string {
+		const { contact_id } = this.contactRef(event);
+		if (!contact_id) {
+			throw createError({ statusCode: 401, statusMessage: "Unauthorized" });
+		}
+		return contact_id;
+	}
+
+	async list(event: H3Event): Promise<AccountAddress[]> {
+		const { contact_id } = this.contactRef(event);
+		if (!contact_id) {
+			return [];
+		}
+		try {
+			// Raw call: the list contract does not declare query params yet.
+			const { items } = await useRevenexxSdk().call<{ items: ApiAddressRow[] }>(
+				"GET",
+				"/v1/customers/addresses",
+				{ query: { contact_id, limit: 200 } },
+			);
+			return items.map(toAccountAddress);
+		}
+		catch (err) {
+			getLogService().error("API request failed: addresses/list", apiErrorContext(err));
+			throw createError({ statusCode: 502, statusMessage: "Address service unavailable" });
+		}
+	}
+
+	async create(event: H3Event, input: AccountAddressFormState): Promise<AccountAddress> {
+		const contactId = this.requireContact(event);
+		const { organization_id } = this.contactRef(event);
+		try {
+			const row = await useRevenexxSdk().customers.customersAddressesCreate({
+				contactId,
+				...(organization_id ? { organizationId: organization_id } : {}),
+				type: input.type === "billing" ? AddressType.Billing : AddressType.Shipping,
+				company: input.company || undefined,
+				name: `${input.firstName} ${input.lastName}`.trim(),
+				street: `${input.street} ${input.streetNumber}`.trim(),
+				zip: input.zip,
+				city: input.city,
+				country: input.country,
+				isDefault: input.isDefault === true,
+			}) as unknown as ApiAddressRow;
+			return toAccountAddress(row);
+		}
+		catch (err) {
+			if (err instanceof RevenexxException && (err.code === 400 || err.code === 422)) {
+				throw createError({ statusCode: 422, message: err.message });
+			}
+			getLogService().error("API request failed: addresses/create", apiErrorContext(err));
+			throw createError({ statusCode: 502, statusMessage: "Address service unavailable" });
+		}
+	}
+
+	async update(event: H3Event, id: string, input: AccountAddressFormState): Promise<AccountAddress> {
+		this.requireContact(event);
+		try {
+			const row = await useRevenexxSdk().customers.customersAddressesUpdate({
+				id,
+				type: input.type === "billing" ? AddressType.Billing : AddressType.Shipping,
+				company: input.company || undefined,
+				name: `${input.firstName} ${input.lastName}`.trim(),
+				street: `${input.street} ${input.streetNumber}`.trim(),
+				zip: input.zip,
+				city: input.city,
+				country: input.country,
+				isDefault: input.isDefault === true,
+			}) as unknown as ApiAddressRow;
+			return toAccountAddress(row);
+		}
+		catch (err) {
+			if (err instanceof RevenexxException && (err.code === 400 || err.code === 422)) {
+				throw createError({ statusCode: 422, message: err.message });
+			}
+			getLogService().error("API request failed: addresses/update", apiErrorContext(err));
+			throw createError({ statusCode: 502, statusMessage: "Address service unavailable" });
+		}
+	}
+
+	async remove(event: H3Event, id: string): Promise<AccountAddress[]> {
+		this.requireContact(event);
+		try {
+			await useRevenexxSdk().customers.customersAddressesDelete({ id });
+		}
+		catch (err) {
+			getLogService().error("API request failed: addresses/delete", apiErrorContext(err));
+			throw createError({ statusCode: 502, statusMessage: "Address service unavailable" });
+		}
+		return this.list(event);
+	}
+}

package/server/services/LocalFileCheckoutProfileService.ts

@@ -1,47 +1,12 @@
+import type { H3Event } from "h3";
+
+import type { AccountAddress } from "../../app/interfaces/account/address-list";
 import type { Address } from "../../app/interfaces/address";
 import type { CheckoutProfile } from "../../app/interfaces/checkout";
 
 import type { ICheckoutProfileService } from "../interfaces/checkoutProfile";
 
-/** Shape of the account address book (account/address-list.json). */
-interface AccountAddressEntry {
-	id: string;
-	company: string;
-	label: string;
-	firstName: string;
-	lastName: string;
-	street: string;
-	streetNumber: string;
-	city: string;
-	zip: string;
-	country: string;
-	isDefault: boolean;
-	type: "billing" | "shipping";
-}
-
-const MOCK_PROFILE: CheckoutProfile = {
-	addresses: [
-		{
-			id: "addr-1",
-			companyName: "Demo GmbH",
-			contactName: "Max Mustermann",
-			street: "Musterstraße 1",
-			city: "Berlin",
-			postalCode: "10115",
-			country: "DE",
-		},
-		{
-			id: "addr-2",
-			companyName: "Demo GmbH",
-			contactName: "Erika Musterfrau",
-			street: "Rechnungsweg 5",
-			city: "Hamburg",
-			postalCode: "20095",
-			country: "DE",
-		},
-	],
-	defaultShippingAddressId: "addr-1",
-	defaultBillingAddressId: "addr-1",
+const BASE_PROFILE: Omit<CheckoutProfile, "addresses" | "defaultShippingAddressId" | "defaultBillingAddressId"> = {
 	availablePaymentMethods: [
 		{ method: "invoice", label: "Rechnung", description: "30 Tage netto" },
 		{ method: "po_number", label: "Bestellschein", description: "Zahlung gemäß Bestellschein" },
@@ -70,25 +35,26 @@ const GUEST_PROFILE: CheckoutProfile = {
 	],
 	defaultPaymentMethod: "invoice",
 	costCenters: [],
-	availableDeliveryMethods: MOCK_PROFILE.availableDeliveryMethods,
+	availableDeliveryMethods: BASE_PROFILE.availableDeliveryMethods,
 	defaultDeliveryMethod: "standard",
 };
 
 /**
- * Checkout profile backed by the account address book: the checkout and
- * /account/addresses read and write the same mutable store, so addresses
- * created in either place show up in both.
+ * Checkout profile backed by the address book service: the checkout and
+ * /account/addresses read and write the same store — the mutable demo
+ * JSON in mock mode, the customers app's contact addresses in live mode
+ * (`addressService` registry key). Payment and delivery options here are
+ * fallbacks; the live checkout resolves them via /api/payment/methods
+ * and /api/shipping/rates.
  */
 export class LocalFileCheckoutProfileService implements ICheckoutProfileService {
-	async getProfile(userId: string | null): Promise<CheckoutProfile> {
+	async getProfile(event: H3Event, userId: string | null): Promise<CheckoutProfile> {
 		if (!userId) {
 			return GUEST_PROFILE;
 		}
 		try {
-			const data = await readCoverMutableJson<{ addresses: AccountAddressEntry[] }>(
-				"account/address-list.json",
-			);
-			const addresses: Address[] = data.addresses.map(entry => ({
+			const entries = await getAddressBookService(event).list(event);
+			const addresses: Address[] = entries.map(entry => ({
 				id: entry.id,
 				companyName: entry.company || `${entry.firstName} ${entry.lastName}`.trim(),
 				contactName: `${entry.firstName} ${entry.lastName}`.trim(),
@@ -97,21 +63,26 @@ export class LocalFileCheckoutProfileService implements ICheckoutProfileService
 				postalCode: entry.zip,
 				country: entry.country,
 			}));
-			const defaultOf = (type: "shipping" | "billing"): string =>
-				data.addresses.find(entry => entry.type === type && entry.isDefault)?.id
-					?? data.addresses.find(entry => entry.type === type)?.id
+			const defaultOf = (type: AccountAddress["type"]): string =>
+				entries.find(entry => entry.type === type && entry.isDefault)?.id
+					?? entries.find(entry => entry.type === type)?.id
 					?? addresses[0]?.id
 					?? "";
 			return {
-				...MOCK_PROFILE,
+				...BASE_PROFILE,
 				addresses,
 				defaultShippingAddressId: defaultOf("shipping"),
 				defaultBillingAddressId: defaultOf("billing"),
 			};
 		}
 		catch {
-			// Address book unavailable — fall back to the bundled profile.
-			return MOCK_PROFILE;
+			// Address book unavailable — checkout still works via add-new.
+			return {
+				...BASE_PROFILE,
+				addresses: [],
+				defaultShippingAddressId: "",
+				defaultBillingAddressId: "",
+			};
 		}
 	}
 }

package/server/services/MockAddressBookService.ts

@@ -0,0 +1,125 @@
+import type { H3Event } from "h3";
+
+import type { AccountAddress, AccountAddressFormState } from "../../app/interfaces/account/address-list";
+
+import type { IAddressBookService } from "../interfaces/addressBook";
+
+interface AddressListRaw {
+	userId: string;
+	addresses: AccountAddress[];
+}
+
+/**
+ * Demo address book backed by the mutable data store — the same JSON the
+ * account pages always used; checkout reads through this service too.
+ */
+export class MockAddressBookService implements IAddressBookService {
+	private async read(): Promise<AddressListRaw> {
+		try {
+			return await readCoverMutableJson<AddressListRaw>("account/address-list.json");
+		}
+		catch {
+			throw createError({ statusCode: 500, statusMessage: "Address store unavailable" });
+		}
+	}
+
+	async list(_event: H3Event): Promise<AccountAddress[]> {
+		return (await this.read()).addresses;
+	}
+
+	async create(_event: H3Event, input: AccountAddressFormState): Promise<AccountAddress> {
+		const data = await this.read();
+		const sameType = data.addresses.filter(a => a.type === input.type);
+		const isDefault = input.isDefault || sameType.length === 0;
+
+		const newAddress: AccountAddress = {
+			id: crypto.randomUUID(),
+			company: input.company ?? "",
+			label: input.label.trim(),
+			firstName: input.firstName.trim(),
+			lastName: input.lastName.trim(),
+			street: input.street.trim(),
+			streetNumber: input.streetNumber.trim(),
+			city: input.city.trim(),
+			zip: input.zip.trim(),
+			country: input.country,
+			type: input.type,
+			isDefault,
+		};
+
+		let addresses = [...data.addresses];
+		if (isDefault) {
+			addresses = addresses.map(a =>
+				a.type === newAddress.type ? { ...a, isDefault: false } : a,
+			);
+		}
+		addresses.push(newAddress);
+
+		await writeCoverMutableJson("account/address-list.json", { ...data, addresses });
+		return newAddress;
+	}
+
+	async update(_event: H3Event, id: string, input: AccountAddressFormState): Promise<AccountAddress> {
+		const data = await this.read();
+		const index = data.addresses.findIndex(a => a.id === id);
+		if (index === -1) {
+			throw createError({ statusCode: 404, statusMessage: "Address not found" });
+		}
+
+		// When setting isDefault, clear it from other addresses of the same type
+		const updated: AccountAddress[] = data.addresses.map((a, i) => {
+			if (i === index) {
+				return {
+					...a,
+					company: input.company,
+					label: input.label,
+					firstName: input.firstName,
+					lastName: input.lastName,
+					street: input.street,
+					streetNumber: input.streetNumber,
+					city: input.city,
+					zip: input.zip,
+					country: input.country,
+					type: input.type,
+					isDefault: input.isDefault,
+				};
+			}
+			if (input.isDefault && a.type === input.type) {
+				return { ...a, isDefault: false };
+			}
+			return a;
+		});
+
+		await writeCoverMutableJson("account/address-list.json", { ...data, addresses: updated });
+		return updated[index]!;
+	}
+
+	async remove(_event: H3Event, id: string): Promise<AccountAddress[]> {
+		const data = await this.read();
+		const address = data.addresses.find(a => a.id === id);
+		if (!address) {
+			throw createError({ statusCode: 404, statusMessage: "Address not found" });
+		}
+
+		const billingCount = data.addresses.filter(a => a.type === "billing").length;
+		if (address.type === "billing" && billingCount <= 1) {
+			throw createError({ statusCode: 400, statusMessage: "Cannot delete the last billing address" });
+		}
+
+		let remaining = data.addresses.filter(a => a.id !== id);
+
+		// If deletion leaves no billing address, promote first shipping to billing + isDefault
+		const hasBilling = remaining.some(a => a.type === "billing");
+		if (!hasBilling && remaining.length > 0) {
+			const firstShippingIdx = remaining.findIndex(a => a.type === "shipping");
+			if (firstShippingIdx !== -1) {
+				remaining = remaining.map((a, i) =>
+					i === firstShippingIdx ? { ...a, type: "billing" as const, isDefault: true } : a,
+				);
+			}
+		}
+
+		await writeCoverMutableJson("account/address-list.json", { ...data, addresses: remaining });
+		return remaining;
+	}
+}

package/server/utils/addressBookService.ts

@@ -0,0 +1,25 @@
+import type { H3Event } from "h3";
+
+import type { IAddressBookService } from "../interfaces/addressBook";
+import { ApiAddressBookService } from "../services/ApiAddressBookService";
+import { MockAddressBookService } from "../services/MockAddressBookService";
+
+/**
+ * Registry of available address book implementations.
+ * The active implementation is selected by the `addressService` key in app.config.ts:
+ * - "mock" — mutable demo address list (account/address-list.json)
+ * - "api"  — the contact's addresses in the customers app (public revenexx API)
+ */
+const serviceRegistry: Record<string, IAddressBookService> = {
+	mock: new MockAddressBookService(),
+	api: new ApiAddressBookService(),
+};
+
+export function getAddressBookService(event?: H3Event): IAddressBookService {
+	const key = resolveServiceKey(event, {
+		domain: "addressService",
+		mockKey: "mock",
+		liveKey: "api",
+	});
+	return serviceRegistry[key] ?? serviceRegistry["mock"]!;
+}