@revenexx/cover 0.1.0

package/server/services/SessionCartService.ts

@@ -0,0 +1,31 @@
+import type { H3Event } from "h3";
+
+import type { CartItem } from "../../app/interfaces/cart-item";
+
+import type { ICartService } from "../interfaces/cart";
+
+/**
+ * Stores cart data in process memory, keyed by the cart session cookie.
+ * Each deployment restart clears all carts — acceptable for mock mode.
+ */
+export class SessionCartService implements ICartService {
+	private readonly store = new Map<string, CartItem[]>();
+
+	async getItems(event: H3Event): Promise<CartItem[]> {
+		return this.store.get(getOrCreateCartSessionId(event)) ?? [];
+	}
+
+	async saveItems(event: H3Event, items: CartItem[]): Promise<void> {
+		const cartId = getOrCreateCartSessionId(event);
+		if (items.length === 0) {
+			this.store.delete(cartId);
+		}
+		else {
+			this.store.set(cartId, items);
+		}
+	}
+
+	async clearItems(event: H3Event): Promise<void> {
+		this.store.delete(getOrCreateCartSessionId(event));
+	}
+}

package/server/utils/accountService.ts

@@ -0,0 +1,30 @@
+import type { H3Event } from "h3";
+
+import type { IAccountService } from "../interfaces/account";
+import { MockAccountService } from "../services/MockAccountService";
+import { SdkAccountService } from "../services/SdkAccountService";
+
+/**
+ * Registry of available account service implementations.
+ * The active implementation is selected by the `accountService` key in app.config.ts:
+ * - "mock" — demo identity from the bundled config asset
+ * - "sdk"  — live identity via the revenexx web SDK (requires NUXT_WEB_SDK_*
+ *            runtime config and an authenticated session)
+ */
+const serviceRegistry: Record<string, IAccountService> = {
+	mock: new MockAccountService("account/user.json"),
+	sdk: new SdkAccountService(),
+};
+
+/**
+ * Returns the account service registered for the current app configuration.
+ * Falls back to "mock" if the configured key is not found.
+ */
+export function getAccountService(event?: H3Event): IAccountService {
+	const key = resolveServiceKey(event, {
+		domain: "accountService",
+		mockKey: "mock",
+		liveKey: "sdk",
+	});
+	return serviceRegistry[key] ?? serviceRegistry["mock"]!;
+}

package/server/utils/authCookie.ts

@@ -0,0 +1,13 @@
+import type { CookieSerializeOptions } from "cookie-es";
+
+export const SESSION_COOKIE_NAME = "cover-session";
+
+export function sessionCookieOptions(expire?: string): CookieSerializeOptions {
+	return {
+		httpOnly: true,
+		secure: !import.meta.dev,
+		sameSite: "lax",
+		path: "/",
+		...(expire ? { expires: new Date(expire) } : {}),
+	};
+}

package/server/utils/authService.ts

@@ -0,0 +1,43 @@
+import type { H3Event } from "h3";
+
+import type { IAuthService } from "../interfaces/auth";
+import { ApiAuthService } from "../services/ApiAuthService";
+import { MockAuthService } from "../services/MockAuthService";
+import { SdkAuthService } from "../services/SdkAuthService";
+
+/**
+ * Registry of available auth implementations:
+ * - "mock" — offline login as bundled B2B demo personas (buyer/approver/admin)
+ * - "api"  — live authentication via the public revenexx API (customers app)
+ * - "sdk"  — live authentication via the revenexx web SDK (direct platform)
+ */
+const mockAuthService = new MockAuthService("account/personas.json");
+
+const serviceRegistry: Record<string, IAuthService> = {
+	mock: mockAuthService,
+	api: new ApiAuthService(),
+	sdk: new SdkAuthService(),
+};
+
+export function getAuthService(event?: H3Event): IAuthService {
+	const key = resolveServiceKey(event, {
+		domain: "authService",
+		mockKey: "mock",
+		liveKey: "api",
+	});
+	return serviceRegistry[key] ?? serviceRegistry["mock"]!;
+}
+
+/** Resolved registry key for endpoints that branch outside the interface. */
+export function resolveAuthServiceKey(event?: H3Event): string {
+	return resolveServiceKey(event, {
+		domain: "authService",
+		mockKey: "mock",
+		liveKey: "api",
+	});
+}
+
+/** The mock instance — exposed for the personas listing endpoint. */
+export function getMockAuthService(): MockAuthService {
+	return mockAuthService;
+}

package/server/utils/b2bService.ts

@@ -0,0 +1,49 @@
+import type { H3Event } from "h3";
+
+import type { OrganizationSettings } from "../../app/interfaces/b2b";
+
+import type { IB2BContextService, IRequisitionService } from "../interfaces/b2bContext";
+import type { ICartCalculationService } from "../interfaces/cartCalculation";
+import { MockB2BContextService, MockRequisitionService } from "../services/MockB2BContextService";
+import { MockCartCalculationService } from "../services/MockCartCalculationService";
+
+/**
+ * Dev-panel override for organization settings: a JSON cookie set by the
+ * demo shop lets every B2B feature flag be toggled per browser session —
+ * the demo equivalent of tenant configuration in a management center.
+ */
+export const ORG_SETTINGS_COOKIE = "cover-org-settings";
+
+export function resolveOrgSettingsOverride(event?: H3Event): Partial<OrganizationSettings> | undefined {
+	if (!event) {
+		return undefined;
+	}
+	const raw = getCookie(event, ORG_SETTINGS_COOKIE);
+	if (!raw) {
+		return undefined;
+	}
+	try {
+		return JSON.parse(raw) as Partial<OrganizationSettings>;
+	}
+	catch {
+		return undefined;
+	}
+}
+
+export function getB2BContextService(event?: H3Event): IB2BContextService {
+	// Per-request instantiation: the service carries the request's settings
+	// override; the underlying data reads are cached by Nitro's storage.
+	return new MockB2BContextService(resolveOrgSettingsOverride(event));
+}
+
+const requisitionService: IRequisitionService = new MockRequisitionService();
+
+export function getRequisitionService(): IRequisitionService {
+	return requisitionService;
+}
+
+const cartCalculationService: ICartCalculationService = new MockCartCalculationService();
+
+export function getCartCalculationService(): ICartCalculationService {
+	return cartCalculationService;
+}

package/server/utils/cartService.ts

@@ -0,0 +1,59 @@
+import { getCookie, setCookie } from "h3";
+import type { H3Event } from "h3";
+import { randomUUID } from "node:crypto";
+
+import type { ICartManager, ICartService } from "../interfaces/cart";
+import { ApiCartService } from "../services/ApiCartService";
+import { SessionCartService } from "../services/SessionCartService";
+
+const CART_SESSION_COOKIE = "cover-cart-session";
+const CART_SESSION_MAX_AGE = 60 * 60 * 24 * 30; // 30 days
+
+/**
+ * Registry of available cart implementations:
+ * - "mock" — in-memory session cart (multi-cart stays client-local)
+ * - "api"  — live carts via the public revenexx API (carts app)
+ */
+const apiCartService = new ApiCartService();
+
+const serviceRegistry: Record<string, ICartService> = {
+	mock: new SessionCartService(),
+	api: apiCartService,
+};
+
+export function getCartService(event?: H3Event): ICartService {
+	const key = resolveServiceKey(event, {
+		domain: "cartService",
+		mockKey: "mock",
+		liveKey: "api",
+	});
+	return serviceRegistry[key] ?? serviceRegistry["mock"]!;
+}
+
+/** The multi-cart manager — live mode only; null in mock mode. */
+export function getCartManager(event?: H3Event): ICartManager | null {
+	const key = resolveServiceKey(event, {
+		domain: "cartService",
+		mockKey: "mock",
+		liveKey: "api",
+	});
+	return key === "api" ? apiCartService : null;
+}
+
+/**
+ * Returns the cart session ID from the request cookie, creating and setting a
+ * new one if it does not exist. Guests own their live session carts by it.
+ */
+export function getOrCreateCartSessionId(event: H3Event): string {
+	let id = getCookie(event, CART_SESSION_COOKIE);
+	if (!id) {
+		id = randomUUID();
+		setCookie(event, CART_SESSION_COOKIE, id, {
+			httpOnly: true,
+			sameSite: "lax",
+			path: "/",
+			maxAge: CART_SESSION_MAX_AGE,
+		});
+	}
+	return id;
+}

package/server/utils/categoryService.ts

@@ -0,0 +1,19 @@
+import type { H3Event } from "h3";
+
+import type { ICategoryService } from "../interfaces/category";
+import { ApiCategoryService } from "../services/ApiCategoryService";
+import { LocalFileCategoryService } from "../services/LocalFileCategoryService";
+
+const serviceRegistry: Record<string, ICategoryService> = {
+	mock: new LocalFileCategoryService("categories.json"),
+	api: new ApiCategoryService(),
+};
+
+export function getCategoryService(event?: H3Event): ICategoryService {
+	const key = resolveServiceKey(event, {
+		domain: "categoryService",
+		mockKey: "mock",
+		liveKey: "api",
+	});
+	return serviceRegistry[key] ?? serviceRegistry["mock"]!;
+}

package/server/utils/checkoutProfileService.ts

@@ -0,0 +1,9 @@
+import type { ICheckoutProfileService } from "../interfaces/checkoutProfile";
+import { LocalFileCheckoutProfileService } from "../services/LocalFileCheckoutProfileService";
+
+const checkoutProfileServiceInstance: ICheckoutProfileService
+	= new LocalFileCheckoutProfileService();
+
+export function getCheckoutProfileService(): ICheckoutProfileService {
+	return checkoutProfileServiceInstance;
+}

package/server/utils/checkoutSession.ts

@@ -0,0 +1,38 @@
+import { randomBytes } from "node:crypto";
+
+const TTL_MS = 2 * 60 * 60 * 1000; // 2 hours
+
+/**
+ * In-memory token store: token → expiry timestamp.
+ *
+ * Tokens are generated when the checkout flow is loaded, and consumed
+ * (one-time use) when an order is submitted. This avoids relying on
+ * browser cookies, which can be stripped by reverse proxies.
+ *
+ * Note: in-memory state is per-process. For multi-instance deployments
+ * replace this with a shared store (Redis, DB, etc.).
+ */
+const tokenStore = new Map<string, number>();
+
+export function createCheckoutSession(): string {
+	const token = randomBytes(32).toString("hex");
+	tokenStore.set(token, Date.now() + TTL_MS);
+	return token;
+}
+
+/**
+ * Validates and consumes a checkout session token (one-time use).
+ * Returns true if the token was valid and has been removed from the store.
+ */
+export function consumeCheckoutSession(token: string): boolean {
+	if (!token) {
+		return false;
+	}
+	const expiry = tokenStore.get(token);
+	if (expiry === undefined || Date.now() > expiry) {
+		tokenStore.delete(token);
+		return false;
+	}
+	tokenStore.delete(token);
+	return true;
+}

package/server/utils/coverData.ts

@@ -0,0 +1,84 @@
+/**
+ * Data access for the cover BFF mock implementations.
+ *
+ * The layer ships its demo data as Nitro server assets (registered in the
+ * layer's nuxt.config via nitro.serverAssets), so reads work identically in
+ * dev and in production builds — regardless of which app consumes the layer.
+ *
+ * Mutable demo state (e.g. the account address book) lives in the consuming
+ * app's `data` storage (.data/kv in dev), seeded from the bundled asset on
+ * first read. The layer package itself is never written to.
+ */
+
+function dataAssets() {
+	return useStorage("assets:cover-data");
+}
+
+function configAssets() {
+	return useStorage("assets:cover-config");
+}
+
+function localeAssets() {
+	return useStorage("assets:cover-locales");
+}
+
+function mutableData() {
+	return useStorage("data");
+}
+
+async function readJsonFrom<T>(storage: ReturnType<typeof useStorage>, key: string): Promise<T> {
+	const raw = await storage.getItemRaw(key);
+	if (raw === null || raw === undefined) {
+		throw new Error(`cover data asset not found: ${key}`);
+	}
+	const text = typeof raw === "string" ? raw : Buffer.from(raw as Uint8Array).toString("utf-8");
+	return JSON.parse(text) as T;
+}
+
+/** Reads a JSON file from the layer's server/data assets. */
+export async function readCoverDataJson<T>(key: string): Promise<T> {
+	return readJsonFrom<T>(dataAssets(), key);
+}
+
+/** Reads a binary file (e.g. product image) from the layer's server/data assets. */
+export async function readCoverDataRaw(key: string): Promise<Buffer | null> {
+	const raw = await dataAssets().getItemRaw(key);
+	if (raw === null || raw === undefined) {
+		return null;
+	}
+	return typeof raw === "string" ? Buffer.from(raw) : Buffer.from(raw as Uint8Array);
+}
+
+/** Reads a JSON file from the layer's server/config assets. */
+export async function readCoverConfigJson<T>(key: string): Promise<T> {
+	return readJsonFrom<T>(configAssets(), key);
+}
+
+/** Reads a locale namespace JSON ({locale}/{namespace}.json) from the layer's i18n assets. */
+export async function readCoverLocaleJson<T>(locale: string, namespace: string): Promise<T | null> {
+	try {
+		return await readJsonFrom<T>(localeAssets(), `${locale}/${namespace}.json`);
+	}
+	catch {
+		return null;
+	}
+}
+
+/**
+ * Reads mutable demo state from the app's data storage, seeding it from the
+ * bundled asset of the same key on first access.
+ */
+export async function readCoverMutableJson<T>(key: string): Promise<T> {
+	const existing = await mutableData().getItem<T>(key);
+	if (existing !== null && existing !== undefined) {
+		return existing;
+	}
+	const seeded = await readCoverDataJson<T>(key);
+	await mutableData().setItem(key, seeded as unknown as object);
+	return seeded;
+}
+
+/** Persists mutable demo state to the app's data storage. */
+export async function writeCoverMutableJson<T>(key: string, value: T): Promise<void> {
+	await mutableData().setItem(key, value as unknown as object);
+}

package/server/utils/governanceStore.ts

@@ -0,0 +1,38 @@
+import type { ApprovalLimit, ApprovalWorkflow, CostCenter } from "../../app/interfaces/b2b";
+
+/**
+ * Mutable governance records created through the account area (demo
+ * persistence). They extend the bundled organization configuration:
+ * `added` arrays append, `patches` overlay base records by id.
+ */
+export interface GovernanceOverrides {
+	costCenters: CostCenter[];
+	costCenterPatches: Record<string, Partial<CostCenter>>;
+	approvalLimits: ApprovalLimit[];
+	workflows: ApprovalWorkflow[];
+	workflowPatches: Record<string, Partial<ApprovalWorkflow>>;
+}
+
+const KEY = "account/governance-overrides.json";
+
+const EMPTY: GovernanceOverrides = {
+	costCenters: [],
+	costCenterPatches: {},
+	approvalLimits: [],
+	workflows: [],
+	workflowPatches: {},
+};
+
+export async function readGovernanceOverrides(): Promise<GovernanceOverrides> {
+	try {
+		const stored = await readCoverMutableJson<Partial<GovernanceOverrides>>(KEY);
+		return { ...EMPTY, ...stored };
+	}
+	catch {
+		return { ...EMPTY };
+	}
+}
+
+export async function writeGovernanceOverrides(overrides: GovernanceOverrides): Promise<void> {
+	await writeCoverMutableJson(KEY, overrides);
+}

package/server/utils/i18n.ts

@@ -0,0 +1,76 @@
+type TranslationRecord = Record<string, unknown>;
+
+const cache = new Map<string, TranslationRecord>();
+
+/**
+ * Loads locale namespaces from the layer's i18n server assets into the cache.
+ * Call this once per request before using the synchronous serverT() — e.g.
+ * at the top of an event handler or service method.
+ */
+export async function preloadLocaleNamespaces(locale: string, namespaces: string[]): Promise<void> {
+	const fallbackLocale = String(useRuntimeConfig().public.defaultLocale);
+	const wanted = locale === fallbackLocale ? [locale] : [locale, fallbackLocale];
+	await Promise.all(wanted.flatMap(loc => namespaces.map(async (ns) => {
+		const key = `${loc}/${ns}`;
+		if (cache.has(key)) {
+			return;
+		}
+		const data = await readCoverLocaleJson<TranslationRecord>(loc, ns);
+		cache.set(key, data ?? {});
+	})));
+}
+
+function getNamespace(locale: string, namespace: string): TranslationRecord {
+	return cache.get(`${locale}/${namespace}`) ?? {};
+}
+
+function getNestedValue(obj: TranslationRecord, keyPath: string): string | undefined {
+	const parts = keyPath.split(".");
+	let current: unknown = obj;
+	for (const part of parts) {
+		if (current === null || typeof current !== "object") {
+			return undefined;
+		}
+		current = (current as TranslationRecord)[part];
+	}
+	return typeof current === "string" ? current : undefined;
+}
+
+/**
+ * Server-side translation utility for pre-translating BFF responses.
+ * Reads from the cached locale namespaces — the relevant namespaces must be
+ * loaded first via preloadLocaleNamespaces().
+ * @param key - dot-separated key path (e.g. "steps.address.title")
+ * @param locale - resolved locale from resolveLocale()
+ * @param namespace - locale file namespace (default: "checkout")
+ * @param params - interpolation values for {placeholder} tokens
+ */
+export function serverT(
+	key: string,
+	locale: string,
+	namespace = "checkout",
+	params?: Record<string, string | number>,
+): string {
+	const interpolate = (template: string): string => {
+		if (!params) {
+			return template;
+		}
+		return template.replace(/\{(\w+)\}/g, (match, name: string) =>
+			name in params ? String(params[name]) : match,
+		);
+	};
+
+	const value = getNestedValue(getNamespace(locale, namespace), key);
+	if (value !== undefined) {
+		return interpolate(value);
+	}
+
+	const fallbackLocale = String(useRuntimeConfig().public.defaultLocale);
+	if (locale !== fallbackLocale) {
+		const fallbackValue = getNestedValue(getNamespace(fallbackLocale, namespace), key);
+		if (fallbackValue !== undefined) {
+			return interpolate(fallbackValue);
+		}
+	}
+	return key;
+}

package/server/utils/inventoryService.ts

@@ -0,0 +1,14 @@
+import type { H3Event } from "h3";
+
+/**
+ * The inventories domain has no service class — endpoints branch on the
+ * resolved registry key ("mock" = demo data already carries stocks,
+ * "api" = the inventories app via the public revenexx API).
+ */
+export function resolveInventoryServiceKey(event?: H3Event): string {
+	return resolveServiceKey(event, {
+		domain: "inventoryService",
+		mockKey: "mock",
+		liveKey: "api",
+	});
+}