@revenexx/cover 0.1.0

package/server/services/ApiMarketService.ts

@@ -0,0 +1,71 @@
+import type { ShopMarket, ShopMarketLocale } from "../../app/interfaces/market";
+import type { IMarketService } from "../interfaces/market";
+
+interface ApiMarketRow {
+	id: string;
+	code: string;
+	name: string;
+	currency: string;
+	status: string;
+	is_default: boolean;
+	position: number;
+}
+
+interface ApiLocaleRow {
+	code: string;
+	language: string;
+	country: string;
+	is_default: boolean;
+	position: number;
+}
+
+interface ApiListPage<T> {
+	items: T[];
+}
+
+const MARKET_CACHE_TTL_MS = 5 * 60 * 1000;
+
+let cache: { markets: ShopMarket[]; loadedAt: number } | null = null;
+
+/**
+ * Live markets via the public revenexx API (markets app):
+ * GET /v1/markets + each market's locales. Cached briefly — the selector
+ * renders on every page and markets change rarely.
+ */
+export class ApiMarketService implements IMarketService {
+	async listMarkets(): Promise<ShopMarket[]> {
+		if (cache && Date.now() - cache.loadedAt < MARKET_CACHE_TTL_MS) {
+			return cache.markets;
+		}
+
+		const api = useRevenexxApi();
+		const { items } = await api.get<ApiListPage<ApiMarketRow>>("/v1/markets");
+		const active = items
+			.filter(m => m.status === "active")
+			.sort((a, b) => a.position - b.position || a.code.localeCompare(b.code));
+
+		const markets = await Promise.all(active.map(async (market): Promise<ShopMarket> => {
+			const { items: locales } = await api.get<ApiListPage<ApiLocaleRow>>(
+				`/v1/markets/${encodeURIComponent(market.id)}/locales`,
+			);
+			return {
+				id: market.id,
+				code: market.code,
+				name: market.name,
+				currency: market.currency,
+				isDefault: market.is_default,
+				locales: locales
+					.sort((a, b) => a.position - b.position)
+					.map((locale): ShopMarketLocale => ({
+						code: locale.code,
+						language: locale.language,
+						country: locale.country,
+						isDefault: locale.is_default,
+					})),
+			};
+		}));
+
+		cache = { markets, loadedAt: Date.now() };
+		return markets;
+	}
+}

package/server/services/ApiProductService.ts

@@ -0,0 +1,53 @@
+import type { Product } from "../../app/composables/useProducts";
+import type { ProductDetail } from "../../app/interfaces/product-detail";
+import type { Locale } from "../utils/locale";
+
+import type { IProductService, ProductListFilter } from "../interfaces/product";
+
+/** Listing cap for the stub — the live index holds tens of thousands of products. */
+const LIST_PAGE_SIZE = 48;
+
+/**
+ * Live product reads via the public revenexx API: the products app's real
+ * Typesense collection, scoped per locale (document id = `{entity_id}:{locale}`).
+ * Prices, stocks and images are not in the index yet — the mapping serves
+ * neutral defaults (see liveCatalog.ts).
+ */
+export class ApiProductService implements IProductService {
+	async listProducts(filter?: ProductListFilter): Promise<Product[]> {
+		const locale: Locale = filter?.locale ?? "de";
+		const filterParts = [`locale:=${tsFilterValue(locale)}`, "enabled:=true"];
+
+		// Category facets carry the category CODE — our category slugs.
+		// Products are indexed with their LEAF category only, so a top-level
+		// category filters across all of its subcategory codes.
+		if (filter?.subcategory) {
+			filterParts.push(`categories:=${tsFilterValue(filter.subcategory)}`);
+		}
+		else if (filter?.category) {
+			const tree = await getLiveCategories(locale);
+			const node = tree.find(c => c.slug === filter.category);
+			const codes = [filter.category, ...(node?.subcategories.map(s => s.slug) ?? [])];
+			filterParts.push(`categories:=[${codes.map(tsFilterValue).join(",")}]`);
+		}
+
+		const result = await searchLiveProducts({
+			q: "*",
+			queryBy: "name,sku",
+			filterBy: filterParts.join(" && "),
+			perPage: LIST_PAGE_SIZE,
+		});
+
+		return (result.hits ?? []).map(hit => mapLiveDocToProduct(hit.document));
+	}
+
+	async getProductById(id: string, locale: Locale = "de"): Promise<Product | null> {
+		const doc = await getLiveProductDoc(id, locale);
+		return doc ? mapLiveDocToProduct(doc) : null;
+	}
+
+	async getProductDetail(id: string, locale: Locale = "de"): Promise<ProductDetail | null> {
+		const doc = await getLiveProductDoc(id, locale);
+		return doc ? mapLiveDocToDetail(doc) : null;
+	}
+}

package/server/services/LocalFileCategoryService.ts

@@ -0,0 +1,23 @@
+import type { ProductCategory } from "../../app/config/navigation";
+import type { ICategoryService } from "../interfaces/category";
+
+/**
+ * Reads categories from a local JSON file.
+ * Replace with a database-backed implementation once a data store is available.
+ */
+export class LocalFileCategoryService implements ICategoryService {
+	private readonly dataKey: string;
+
+	constructor(dataKey: string) {
+		this.dataKey = dataKey;
+	}
+
+	async listCategories(): Promise<ProductCategory[]> {
+		return readCoverDataJson<ProductCategory[]>(this.dataKey);
+	}
+
+	async getCategoryBySlug(slug: string): Promise<ProductCategory | null> {
+		const categories = await this.listCategories();
+		return categories.find(c => c.slug === slug) ?? null;
+	}
+}

package/server/services/LocalFileCheckoutProfileService.ts

@@ -0,0 +1,117 @@
+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",
+	availablePaymentMethods: [
+		{ method: "invoice", label: "Rechnung", description: "30 Tage netto" },
+		{ method: "po_number", label: "Bestellschein", description: "Zahlung gemäß Bestellschein" },
+		{ method: "cost_center", label: "Kostenstelle", description: "Interne Verrechnung" },
+	],
+	defaultPaymentMethod: "invoice",
+	costCenters: [
+		{ id: "cc-1", code: "CC-100", label: "Marketing" },
+		{ id: "cc-2", code: "CC-200", label: "Engineering" },
+		{ id: "cc-3", code: "CC-300", label: "Operations" },
+	],
+	availableDeliveryMethods: [
+		{ method: "standard", label: "Standard", price: 0, eta: "3–5" },
+		{ method: "express", label: "Express", price: 9.90, eta: "1–2" },
+	],
+	defaultDeliveryMethod: "standard",
+};
+
+/** Checkout options for guests: no address book, invoice only. */
+const GUEST_PROFILE: CheckoutProfile = {
+	addresses: [],
+	defaultShippingAddressId: "",
+	defaultBillingAddressId: "",
+	availablePaymentMethods: [
+		{ method: "invoice", label: "Rechnung", description: "Zahlbar nach Erhalt" },
+	],
+	defaultPaymentMethod: "invoice",
+	costCenters: [],
+	availableDeliveryMethods: MOCK_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.
+ */
+export class LocalFileCheckoutProfileService implements ICheckoutProfileService {
+	async getProfile(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 => ({
+				id: entry.id,
+				companyName: entry.company || `${entry.firstName} ${entry.lastName}`.trim(),
+				contactName: `${entry.firstName} ${entry.lastName}`.trim(),
+				street: `${entry.street} ${entry.streetNumber}`.trim(),
+				city: entry.city,
+				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
+					?? addresses[0]?.id
+					?? "";
+			return {
+				...MOCK_PROFILE,
+				addresses,
+				defaultShippingAddressId: defaultOf("shipping"),
+				defaultBillingAddressId: defaultOf("billing"),
+			};
+		}
+		catch {
+			// Address book unavailable — fall back to the bundled profile.
+			return MOCK_PROFILE;
+		}
+	}
+}

package/server/services/LocalFileProductService.ts

@@ -0,0 +1,128 @@
+import type { Product } from "../../app/composables/useProducts";
+import type { ProductDetail } from "../../app/interfaces/product-detail";
+
+import type { IProductService, ProductListFilter } from "../interfaces/product";
+
+interface SourceProduct {
+	id: number;
+	name: string;
+	sku: string;
+	available: boolean;
+}
+
+interface SourceCategory {
+	type: string;
+	name: string;
+}
+
+interface SourceImage {
+	type: string;
+	priority: number;
+	url: string;
+}
+
+interface SourceStock {
+	quantity: number;
+	maxOrderQuantity: number;
+}
+
+interface SourceTax {
+	rate?: number;
+	includedInPrice?: boolean;
+}
+
+interface SourceItem {
+	product: SourceProduct[];
+	categories: SourceCategory[];
+	images: SourceImage[];
+	stocks: SourceStock[];
+	prices: { [key: string]: number }[];
+	tax?: SourceTax;
+}
+
+function mapToProduct(source: SourceItem): Product | null {
+	const mainProduct = source.product[0];
+	if (!mainProduct) {
+		return null;
+	}
+
+	const slugPath = source.categories.find(c => c.type === "slug")?.name ?? "";
+	const slugSegments = slugPath.split("/").filter(Boolean);
+	const categorySlug = slugSegments[0] ?? "";
+	const candidateSubcategory = slugSegments[1];
+	const subcategorySlug = candidateSubcategory && candidateSubcategory !== "product" && candidateSubcategory !== "products"
+		? candidateSubcategory
+		: undefined;
+
+	const categoryName = source.categories.find(c => c.type === "main")?.name ?? categorySlug;
+	const subcategoryName = source.categories.find(c => c.type === "subcategory")?.name;
+
+	const primaryImage = [...(source.images ?? [])]
+		.sort((a, b) => a.priority - b.priority)
+		.find(img => img.type === "main")?.url
+		?? source.images?.[0]?.url
+		?? "";
+
+	const maxOrderQuantity = source.stocks?.[0]?.maxOrderQuantity;
+	const taxRate = typeof source.tax?.rate === "number" && Number.isFinite(source.tax.rate)
+		? source.tax.rate
+		: 0;
+
+	return {
+		// Demo JSON carries numeric ids — the contract is string (UUID live).
+		id: String(mainProduct.id),
+		name: mainProduct.name,
+		sku: mainProduct.sku,
+		available: mainProduct.available,
+		prices: source.prices ?? [],
+		tax: { rate: taxRate, includedInPrice: source.tax?.includedInPrice },
+		stocks: source.stocks ?? [],
+		...(typeof maxOrderQuantity === "number" ? { maxOrderQuantity } : {}),
+		image: primaryImage,
+		category: categoryName,
+		categorySlug,
+		...(subcategoryName ? { subcategory: subcategoryName } : {}),
+		...(subcategorySlug ? { subcategorySlug } : {}),
+	};
+}
+
+/**
+ * Reads product list and product detail from local JSON files.
+ * Mirrors the lookup pattern of a real database-backed product service.
+ * Replace with a database-backed implementation once a data store is available.
+ */
+export class LocalFileProductService implements IProductService {
+	private readonly listKey: string;
+	private readonly detailKey: string;
+
+	constructor(listKey: string, detailKey: string) {
+		this.listKey = listKey;
+		this.detailKey = detailKey;
+	}
+
+	async listProducts(filter?: ProductListFilter): Promise<Product[]> {
+		const all = (await readCoverDataJson<SourceItem[]>(this.listKey))
+			.map(mapToProduct)
+			.filter((p): p is Product => p !== null);
+
+		return all.filter((product) => {
+			if (filter?.category && product.categorySlug !== filter.category) {
+				return false;
+			}
+			if (filter?.subcategory && product.subcategorySlug !== filter.subcategory) {
+				return false;
+			}
+			return true;
+		});
+	}
+
+	async getProductById(id: string): Promise<Product | null> {
+		const products = await this.listProducts();
+		return products.find(p => p.id === id) ?? null;
+	}
+
+	async getProductDetail(id: string): Promise<ProductDetail | null> {
+		const all = await readCoverDataJson<Record<string, ProductDetail>>(this.detailKey);
+		return all[id] ?? null;
+	}
+}

package/server/services/LocalFileSchemaService.ts

@@ -0,0 +1,70 @@
+import type { ISchemaService, ISchemaTranslator, SchemaObject, SchemaValue } from "../interfaces/schema";
+
+/**
+ * Loads form schemas from local JSON files and translates i18n keys server-side.
+ * getSchema() returns a fully translated, ready-to-serve schema.
+ * This is the default implementation; swap it out via app.config → schemaService
+ * when schemas are served from a remote CMS or API.
+ */
+export class LocalFileSchemaService implements ISchemaService, ISchemaTranslator {
+	private readonly basePrefix: string;
+	private readonly rawCache = new Map<string, SchemaObject>();
+
+	constructor(basePrefix: string) {
+		this.basePrefix = basePrefix;
+	}
+
+	private async loadRaw(key: string): Promise<SchemaObject> {
+		if (this.rawCache.has(key)) {
+			return this.rawCache.get(key)!;
+		}
+		const schema = await readCoverDataJson<SchemaObject>(`${this.basePrefix}/${key}.json`);
+		this.rawCache.set(key, schema);
+		return schema;
+	}
+
+	translateSchema(schema: SchemaValue, locale: string): SchemaValue {
+		if (Array.isArray(schema)) {
+			return schema.map(item => this.translateSchema(item, locale));
+		}
+		if (schema !== null && typeof schema === "object") {
+			const obj = schema as SchemaObject;
+			const result: SchemaObject = {};
+			for (const [key, value] of Object.entries(obj)) {
+				if ((key === "title" || key === "label") && typeof value === "string" && !value.includes(" ")) {
+					result[key] = serverT(value, locale);
+				}
+				else if (key === "message" && typeof value === "string" && !value.includes(" ")) {
+					result[key] = serverT(value.split(".").pop()!, locale, "validation");
+				}
+				else if (key === "validationMessages" && value !== null && typeof value === "object") {
+					// FormKit: { rule: "validation.key" } — values are i18n keys.
+					result[key] = Object.fromEntries(
+						Object.entries(value as Record<string, string>).map(([rule, msg]) => [
+							rule,
+							typeof msg === "string" && !msg.includes(" ")
+								? serverT(msg.split(".").pop()!, locale, "validation")
+								: msg,
+						]),
+					);
+				}
+				else if (key === "children" && typeof value === "string" && !value.includes(" ") && value.includes(".")) {
+					// FormKit $el nodes: a key-like string child is an i18n key
+					// (e.g. section headings); literal texts contain spaces.
+					result[key] = serverT(value, locale);
+				}
+				else {
+					result[key] = this.translateSchema(value, locale);
+				}
+			}
+			return result;
+		}
+		return schema;
+	}
+
+	async getSchema(key: string, locale: string): Promise<SchemaObject> {
+		const raw = await this.loadRaw(key);
+		await preloadLocaleNamespaces(locale, ["checkout", "validation"]);
+		return this.translateSchema(raw, locale) as SchemaObject;
+	}
+}

package/server/services/LocalFileThemeService.ts

@@ -0,0 +1,18 @@
+import type { Theme } from "../../app/config/themes";
+import type { IThemeService } from "../interfaces/theme";
+
+/**
+ * Reads themes from a local JSON file.
+ * Replace with a database-backed implementation once a data store is available.
+ */
+export class LocalFileThemeService implements IThemeService {
+	private readonly dataKey: string;
+
+	constructor(dataKey: string) {
+		this.dataKey = dataKey;
+	}
+
+	async listThemes(): Promise<Theme[]> {
+		return readCoverDataJson<Theme[]>(this.dataKey);
+	}
+}

package/server/services/LogService.ts

@@ -0,0 +1,28 @@
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+import type { ILogService } from "../interfaces/log";
+
+export class LogService implements ILogService {
+	private readonly logPath: string;
+
+	constructor(logPath: string) {
+		this.logPath = logPath;
+		mkdirSync(dirname(logPath), { recursive: true });
+	}
+
+	error(message: string, context?: Record<string, unknown>): void {
+		const entry = JSON.stringify({
+			level: "error",
+			timestamp: new Date().toISOString(),
+			message,
+			...context,
+		});
+		try {
+			appendFileSync(this.logPath, entry + "\n");
+		}
+		catch {
+			console.error("[LogService] Failed to write log entry:", entry);
+		}
+	}
+}

package/server/services/MockAccountService.ts

@@ -0,0 +1,58 @@
+import type { H3Event } from "h3";
+
+import type { StoredSession } from "../../app/interfaces/auth";
+import type { AuthPersona } from "../interfaces/auth";
+import type { AccountUser, IAccountService } from "../interfaces/account";
+
+/**
+ * Stub implementation reading users from a local JSON file and querying by ID.
+ * Mirrors the lookup pattern of a real database-backed identity service.
+ * Until auth is available, always resolves the user with id=1.
+ * Replace with a real identity service implementation once auth is available.
+ */
+export class MockAccountService implements IAccountService {
+	private readonly configKey: string;
+
+	constructor(configKey: string) {
+		this.configKey = configKey;
+	}
+
+	async getUser(event?: H3Event): Promise<AccountUser> {
+		// When a mock persona is signed in, the identity is that persona —
+		// this keeps account pages consistent with the auth simulation.
+		const persona = event ? await this.personaFromSession(event) : null;
+		if (persona) {
+			return {
+				id: persona.id,
+				name: persona.name,
+				email: persona.email,
+				initials: persona.name.split(/\s+/).slice(0, 2).map(p => p[0]?.toUpperCase() ?? "").join(""),
+			};
+		}
+
+		const users = await readCoverConfigJson<AccountUser[]>(this.configKey);
+		const user = users.find(u => u.id === 1);
+		if (!user) {
+			throw new Error("MockAccountService: user with id=1 not found in config");
+		}
+		return user;
+	}
+
+	private async personaFromSession(event: H3Event): Promise<AuthPersona | null> {
+		const raw = getCookie(event, SESSION_COOKIE_NAME);
+		if (!raw) {
+			return null;
+		}
+		try {
+			const session = JSON.parse(raw) as StoredSession;
+			if (!session.personaId) {
+				return null;
+			}
+			const personas = await readCoverConfigJson<AuthPersona[]>("account/personas.json");
+			return personas.find(p => p.id === session.personaId) ?? null;
+		}
+		catch {
+			return null;
+		}
+	}
+}

package/server/services/MockAuthService.ts

@@ -0,0 +1,105 @@
+import type { H3Event } from "h3";
+
+import type { AuthUser, StoredSession } from "../../app/interfaces/auth";
+import type { AuthLoginResult, AuthPersona, IAuthService } from "../interfaces/auth";
+
+const SESSION_TTL_MS = 1000 * 60 * 60 * 12; // 12h demo session
+
+/**
+ * Offline authentication against the bundled B2B demo personas.
+ * Any password signs a persona in — this is a demo tool, not a security
+ * boundary. Unknown emails are rejected with the same error shape the SDK
+ * implementation produces, so the client-side flow behaves identically.
+ */
+export class MockAuthService implements IAuthService {
+	private readonly personasKey: string;
+
+	constructor(personasKey: string) {
+		this.personasKey = personasKey;
+	}
+
+	async listPersonas(): Promise<AuthPersona[]> {
+		return readCoverConfigJson<AuthPersona[]>(this.personasKey);
+	}
+
+	/** Users registered through the storefront (demo persistence), as personas. */
+	private async listRegisteredUsers(): Promise<AuthPersona[]> {
+		try {
+			const store = await readCoverMutableJson<{
+				requests: { userId: string; name: string; email: string }[];
+			}>("account/registration-requests.json");
+			return store.requests.map(request => ({
+				id: request.userId,
+				name: request.name,
+				email: request.email,
+				role: "buyer" as const,
+				description: "Registered demo user",
+			}));
+		}
+		catch {
+			return [];
+		}
+	}
+
+	private async findPersona(predicate: (p: AuthPersona) => boolean): Promise<AuthPersona | null> {
+		const personas = await this.listPersonas();
+		const registered = await this.listRegisteredUsers();
+		return [...personas, ...registered].find(predicate) ?? null;
+	}
+
+	private toUser(persona: AuthPersona): AuthUser {
+		return { $id: persona.id, name: persona.name, email: persona.email, role: persona.role };
+	}
+
+	async login(event: H3Event, email: string): Promise<AuthLoginResult> {
+		const persona = await this.findPersona(p => p.email.toLowerCase() === email.toLowerCase());
+		if (!persona) {
+			throw createError({ statusCode: 401, data: { type: "user_invalid_credentials" } });
+		}
+
+		const expire = new Date(Date.now() + SESSION_TTL_MS).toISOString();
+		const session: StoredSession = {
+			id: `mock-${persona.id}`,
+			expire,
+			personaId: persona.id,
+		};
+		setCookie(event, SESSION_COOKIE_NAME, JSON.stringify(session), sessionCookieOptions(expire));
+
+		return {
+			user: this.toUser(persona),
+			session: { id: session.id, expire },
+		};
+	}
+
+	async me(event: H3Event): Promise<AuthUser | null> {
+		const raw = getCookie(event, SESSION_COOKIE_NAME);
+		if (!raw) {
+			return null;
+		}
+
+		let session: StoredSession;
+		try {
+			session = JSON.parse(raw) as StoredSession;
+		}
+		catch {
+			deleteCookie(event, SESSION_COOKIE_NAME, sessionCookieOptions());
+			return null;
+		}
+
+		if (!session.personaId || new Date(session.expire).getTime() < Date.now()) {
+			deleteCookie(event, SESSION_COOKIE_NAME, sessionCookieOptions());
+			return null;
+		}
+
+		const persona = await this.findPersona(p => p.id === session.personaId);
+		if (!persona) {
+			deleteCookie(event, SESSION_COOKIE_NAME, sessionCookieOptions());
+			return null;
+		}
+		return this.toUser(persona);
+	}
+
+	async logout(event: H3Event): Promise<void> {
+		deleteCookie(event, SESSION_COOKIE_NAME, sessionCookieOptions());
+	}
+}