@revenexx/cover 0.1.0 → 0.1.2

package/server/services/ApiAuthService.ts

@@ -34,9 +34,9 @@ function contactName(contact: ApiContact | null, fallback: string): string {
 
 /**
  * Live authentication via the public revenexx API (customers app):
- *   POST /v1/customers/auth/login   → platform session (incl. secret) + contact
- *   POST /v1/customers/auth/me      → platform user + contact
- *   POST /v1/customers/auth/logout  → revokes the platform session
+ *   customersAuthLogin   → platform session (incl. secret) + contact
+ *   auth/me (raw call)   → platform user + contact
+ *   customersAuthLogout  → revokes the platform session
  *
  * Session state lives in the same cookie as the other implementations, so
  * the client-side auth flow (store, guards, middleware) is identical. The
@@ -44,11 +44,10 @@ function contactName(contact: ApiContact | null, fallback: string): string {
  */
 export class ApiAuthService implements IAuthService {
 	async login(event: H3Event, email: string, password: string): Promise<AuthLoginResult> {
-		const api = useRevenexxApi();
-		const { session, contact } = await api.post<{ session: ApiSession; contact: ApiContact | null }>(
-			"/v1/customers/auth/login",
-			{ email, password },
-		);
+		const { session, contact } = await useRevenexxSdk().customers.customersAuthLogin({ email, password }) as unknown as {
+			session: ApiSession;
+			contact: ApiContact | null;
+		};
 
 		const storedSession: StoredSession = {
 			id: session.$id,
@@ -94,11 +93,13 @@ export class ApiAuthService implements IAuthService {
 
 		try {
 			// session_id makes the customers app validate the session is still
-			// alive — a logged-out/revoked session answers 401 here.
-			const { user, contact } = await useRevenexxApi().post<{
+			// alive — a logged-out/revoked session answers 401 here. Raw call:
+			// the AuthMeRequest contract does not declare session_id yet, so
+			// the generated customersAuthMe() would drop the session check.
+			const { user, contact } = await useRevenexxSdk().call<{
 				user: { $id: string; name?: string; email: string };
 				contact: ApiContact | null;
-			}>("/v1/customers/auth/me", { user_id: parsed.userId, session_id: parsed.id });
+			}>("POST", "/v1/customers/auth/me", { body: { user_id: parsed.userId, session_id: parsed.id } });
 
 			return {
 				$id: user.$id,
@@ -122,9 +123,9 @@ export class ApiAuthService implements IAuthService {
 			try {
 				const parsed = JSON.parse(raw) as StoredSession;
 				if (parsed.userId && parsed.id) {
-					await useRevenexxApi().post("/v1/customers/auth/logout", {
-						user_id: parsed.userId,
-						session_id: parsed.id,
+					await useRevenexxSdk().customers.customersAuthLogout({
+						userId: parsed.userId,
+						sessionId: parsed.id,
 					});
 				}
 			}

package/server/services/ApiCartService.ts

@@ -1,4 +1,5 @@
 import type { H3Event } from "h3";
+import type { Models } from "@revenexx/sdk";
 
 import type { CartItem } from "../../app/interfaces/cart-item";
 import type { StoredSession } from "../../app/interfaces/auth";
@@ -137,11 +138,15 @@ function toSummary(cart: ApiCart): CartSummaryRow {
  */
 export class ApiCartService implements ICartService, ICartManager {
 	private async listActive(owner: CartOwner): Promise<ApiCart[]> {
-		const { items } = await useRevenexxApi().get<{ items: ApiCart[] }>("/v1/carts", {
-			...ownerQuery(owner),
-			status: "active",
-			limit: 100,
-			order: "updated_at.desc",
+		// Raw call: carts.list does not declare its query parameters in the
+		// contract yet, so the generated cartsList() cannot filter by owner.
+		const { items } = await useRevenexxSdk().call<{ items: ApiCart[] }>("GET", "/v1/carts", {
+			query: {
+				...ownerQuery(owner),
+				status: "active",
+				limit: 100,
+				order: "updated_at.desc",
+			},
 		});
 		return items;
 	}
@@ -152,11 +157,11 @@ export class ApiCartService implements ICartService, ICartManager {
 		if (current) {
 			return current;
 		}
-		return useRevenexxApi().post<ApiCart>("/v1/carts", {
+		return await useRevenexxSdk().carts.cartsCreate({
 			name: DEFAULT_CART_NAME,
-			...(owner.contactId ? { contact_id: owner.contactId } : { session_key: owner.sessionKey }),
-			is_current: true,
-		});
+			...(owner.contactId ? { contactId: owner.contactId } : { sessionKey: owner.sessionKey }),
+			isCurrent: true,
+		}) as unknown as ApiCart;
 	}
 
 	// ---- ICartService (the active cart) --------------------------------
@@ -168,16 +173,16 @@ export class ApiCartService implements ICartService, ICartManager {
 		if (!current) {
 			return [];
 		}
-		const { items } = await useRevenexxApi().get<{ items: ApiCartLine[] }>(`/v1/carts/${current.id}/items`);
+		const { items } = await useRevenexxSdk().carts.cartsItemsList({ cartId: current.id }) as unknown as { items: ApiCartLine[] };
 		return items.map(toCartItem);
 	}
 
 	async saveItems(event: H3Event, items: CartItem[]): Promise<void> {
 		const owner = resolveOwner(event);
 		const cart = await this.ensureActiveCart(owner);
-		await useRevenexxApi().request(`/v1/carts/${cart.id}/items`, {
-			method: "PUT",
-			body: { items: items.map((item, index) => toApiLine(item, index)) },
+		await useRevenexxSdk().carts.cartsItemsReplace({
+			cartId: cart.id,
+			items: items.map((item, index) => toApiLine(item, index)) as unknown as Models.CartItemCreateRequest[],
 		});
 	}
 
@@ -199,30 +204,43 @@ export class ApiCartService implements ICartService, ICartManager {
 
 	async createCart(event: H3Event, name: string, activate: boolean): Promise<CartSummaryRow> {
 		const owner = resolveOwner(event);
-		const cart = await useRevenexxApi().post<ApiCart>("/v1/carts", {
+		const cart = await useRevenexxSdk().carts.cartsCreate({
 			name: name.trim() || DEFAULT_CART_NAME,
-			...(owner.contactId ? { contact_id: owner.contactId } : { session_key: owner.sessionKey }),
-			is_current: activate,
-		});
+			...(owner.contactId ? { contactId: owner.contactId } : { sessionKey: owner.sessionKey }),
+			isCurrent: activate,
+		}) as unknown as ApiCart;
 		return { ...toSummary(cart), active: activate };
 	}
 
 	async renameCart(event: H3Event, id: string, name: string): Promise<void> {
-		await useRevenexxApi().put(`/v1/carts/${id}`, { name: name.trim() });
+		await useRevenexxSdk().carts.cartsUpdate({ id, name: name.trim() });
 	}
 
 	async deleteCart(event: H3Event, id: string): Promise<void> {
-		await useRevenexxApi().request(`/v1/carts/${id}`, { method: "DELETE" });
+		await useRevenexxSdk().carts.cartsDelete({ id });
 	}
 
 	async activateCart(event: H3Event, id: string): Promise<CartItem[]> {
-		await useRevenexxApi().post(`/v1/carts/${id}/activate`, {});
-		const { items } = await useRevenexxApi().get<{ items: ApiCartLine[] }>(`/v1/carts/${id}/items`);
+		await useRevenexxSdk().carts.cartsActivate({ id });
+		const { items } = await useRevenexxSdk().carts.cartsItemsList({ cartId: id }) as unknown as { items: ApiCartLine[] };
 		return items.map(toCartItem);
 	}
 
 	async addItemToCart(event: H3Event, id: string, item: CartItem): Promise<void> {
-		await useRevenexxApi().post(`/v1/carts/${id}/items`, toApiLine(item, 0));
+		const line = toApiLine(item, 0);
+		await useRevenexxSdk().carts.cartsItemsCreate({
+			cartId: id,
+			...(line.product_id ? { productId: String(line.product_id) } : {}),
+			...(line.sku ? { sku: String(line.sku) } : {}),
+			name: String(line.name),
+			quantity: Number(line.quantity),
+			...(line.unit ? { unit: String(line.unit) } : {}),
+			unitPrice: Number(line.unit_price),
+			taxRate: Number(line.tax_rate),
+			position: Number(line.position),
+			snapshot: line.snapshot as object,
+			metadata: line.metadata as object,
+		});
 	}
 
 	async orderActiveCart(event: H3Event, orderRef: string): Promise<string | null> {
@@ -232,7 +250,7 @@ export class ApiCartService implements ICartService, ICartManager {
 		if (!current) {
 			return null;
 		}
-		await useRevenexxApi().post(`/v1/carts/${current.id}/order`, { order_ref: orderRef });
+		await useRevenexxSdk().carts.cartsOrder({ id: current.id, orderRef });
 		return current.id;
 	}
 
@@ -245,10 +263,10 @@ export class ApiCartService implements ICartService, ICartManager {
 		// the session cart is adopted as the customer's cart.
 		const customerCarts = await this.listActive({ contactId, sessionKey: "" });
 		const target = customerCarts.find(c => c.is_current) ?? customerCarts[0];
-		await useRevenexxApi().post("/v1/carts/claim", {
-			session_key: sessionKey,
-			contact_id: contactId,
-			...(target ? { target_cart_id: target.id } : {}),
+		await useRevenexxSdk().carts.cartsClaim({
+			sessionKey,
+			contactId,
+			...(target ? { targetCartId: target.id } : {}),
 		});
 	}
 }

package/server/services/ApiMarketService.ts

@@ -25,7 +25,9 @@ interface ApiListPage<T> {
 
 const MARKET_CACHE_TTL_MS = 5 * 60 * 1000;
 
-let cache: { markets: ShopMarket[]; loadedAt: number } | null = null;
+// Partitioned by tenant — a multi-tenant theme must never serve one
+// tenant's markets to another (see revenexxTenantKey()).
+const cache = new Map<string, { markets: ShopMarket[]; loadedAt: number }>();
 
 /**
  * Live markets via the public revenexx API (markets app):
@@ -34,20 +36,20 @@ let cache: { markets: ShopMarket[]; loadedAt: number } | null = null;
  */
 export class ApiMarketService implements IMarketService {
 	async listMarkets(): Promise<ShopMarket[]> {
-		if (cache && Date.now() - cache.loadedAt < MARKET_CACHE_TTL_MS) {
-			return cache.markets;
+		const tenantKey = revenexxTenantKey();
+		const cached = cache.get(tenantKey);
+		if (cached && Date.now() - cached.loadedAt < MARKET_CACHE_TTL_MS) {
+			return cached.markets;
 		}
 
-		const api = useRevenexxApi();
-		const { items } = await api.get<ApiListPage<ApiMarketRow>>("/v1/markets");
+		const sdk = useRevenexxSdk();
+		const { items } = await sdk.markets.marketsList() as unknown as ApiListPage<ApiMarketRow>;
 		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`,
-			);
+			const { items: locales } = await sdk.markets.marketsLocalesList({ marketId: market.id }) as unknown as ApiListPage<ApiLocaleRow>;
 			return {
 				id: market.id,
 				code: market.code,
@@ -65,7 +67,7 @@ export class ApiMarketService implements IMarketService {
 			};
 		}));
 
-		cache = { markets, loadedAt: Date.now() };
+		cache.set(tenantKey, { markets, loadedAt: Date.now() });
 		return markets;
 	}
 }

package/server/utils/accountService.ts

@@ -1,19 +1,18 @@
 import type { H3Event } from "h3";
 
 import type { IAccountService } from "../interfaces/account";
+import { ApiAccountService } from "../services/ApiAccountService";
 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)
+ * - "api"  — live identity via the public revenexx API (customers app)
  */
 const serviceRegistry: Record<string, IAccountService> = {
 	mock: new MockAccountService("account/user.json"),
-	sdk: new SdkAccountService(),
+	api: new ApiAccountService(),
 };
 
 /**
@@ -24,7 +23,7 @@ export function getAccountService(event?: H3Event): IAccountService {
 	const key = resolveServiceKey(event, {
 		domain: "accountService",
 		mockKey: "mock",
-		liveKey: "sdk",
+		liveKey: "api",
 	});
 	return serviceRegistry[key] ?? serviceRegistry["mock"]!;
 }

package/server/utils/authService.ts

@@ -3,20 +3,17 @@ 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 {

package/server/utils/liveCatalog.ts

@@ -1,3 +1,5 @@
+import { Collection } from "@revenexx/sdk";
+
 import type { ProductCategory, ProductSubcategory } from "../../app/config/navigation";
 import type { Product } from "../../app/composables/useProducts";
 import type { ProductDetail } from "../../app/interfaces/product-detail";
@@ -58,16 +60,22 @@ const LIVE_DEFAULT_TAX_RATE = 19;
 const LIVE_DEFAULT_STOCK = { quantity: 9999, maxOrderQuantity: 999999 };
 
 export async function searchLiveProducts(params: LiveSearchParams): Promise<LiveSearchResponse> {
-	return useRevenexxApi().get<LiveSearchResponse>(
-		"/v1/search/collections/products/documents/search",
+	// Raw call (GET form): the gateway currently 404s the POST search route
+	// its spec declares, and the GET contract does not declare facet_by —
+	// the generated search methods can't cover this call yet.
+	return useRevenexxSdk().call<LiveSearchResponse>(
+		"GET",
+		`/v1/search/collections/${Collection.Products}/documents/search`,
 		{
-			q: params.q,
-			query_by: params.queryBy ?? "name,sku,description,manufacturer",
-			filter_by: params.filterBy,
-			facet_by: params.facetBy,
-			sort_by: params.sortBy,
-			page: params.page ?? 1,
-			per_page: params.perPage ?? 24,
+			query: {
+				q: params.q,
+				query_by: params.queryBy ?? "name,sku,description,manufacturer",
+				filter_by: params.filterBy,
+				facet_by: params.facetBy,
+				sort_by: params.sortBy,
+				page: params.page ?? 1,
+				per_page: params.perPage ?? 24,
+			},
 		},
 	);
 }
@@ -167,21 +175,26 @@ interface LiveCategoryPage {
 const CATEGORY_CACHE_TTL_MS = 5 * 60 * 1000;
 const CATEGORY_PAGE_LIMIT = 200;
 
-let categoryCache: { rows: LiveCategoryRow[]; loadedAt: number } | null = null;
+// Partitioned by tenant — a multi-tenant theme must never serve one
+// tenant's category tree to another (see revenexxTenantKey()).
+const categoryCache = new Map<string, { rows: LiveCategoryRow[]; loadedAt: number }>();
 
 async function loadLiveCategoryRows(): Promise<LiveCategoryRow[]> {
-	if (categoryCache && Date.now() - categoryCache.loadedAt < CATEGORY_CACHE_TTL_MS) {
-		return categoryCache.rows;
+	const tenantKey = revenexxTenantKey();
+	const cached = categoryCache.get(tenantKey);
+	if (cached && Date.now() - cached.loadedAt < CATEGORY_CACHE_TTL_MS) {
+		return cached.rows;
 	}
 
-	const api = useRevenexxApi();
+	const sdk = useRevenexxSdk();
 	const rows: LiveCategoryRow[] = [];
 	let offset = 0;
 	// Paginate defensively — the demo tenant has a few hundred categories.
+	// Raw call: the categories list contract does not declare limit/offset
+	// yet, so the generated productsCategoriesList() cannot paginate.
 	for (let pageIndex = 0; pageIndex < 25; pageIndex++) {
-		const page = await api.get<LiveCategoryPage>("/v1/products/categories", {
-			limit: CATEGORY_PAGE_LIMIT,
-			offset,
+		const page = await sdk.call<LiveCategoryPage>("GET", "/v1/products/categories", {
+			query: { limit: CATEGORY_PAGE_LIMIT, offset },
 		});
 		rows.push(...page.items);
 		if (!page.page.hasMore) {
@@ -190,7 +203,7 @@ async function loadLiveCategoryRows(): Promise<LiveCategoryRow[]> {
 		offset += page.page.returned;
 	}
 
-	categoryCache = { rows, loadedAt: Date.now() };
+	categoryCache.set(tenantKey, { rows, loadedAt: Date.now() });
 	return rows;
 }
 

package/server/utils/liveInventories.ts

@@ -1,4 +1,5 @@
 import type { H3Event } from "h3";
+import type { Models } from "@revenexx/sdk";
 
 import type { Product } from "../../app/composables/useProducts";
 import type { ProductDetail } from "../../app/interfaces/product-detail";
@@ -30,10 +31,9 @@ function toStock(entry: ItemAvailability): { quantity: number; maxOrderQuantity:
 }
 
 async function fetchAvailability(items: Array<{ product_id?: string; sku?: string }>): Promise<Map<string, ItemAvailability>> {
-	const { availability } = await useRevenexxApi().post<{ availability: ItemAvailability[] }>(
-		"/v1/inventories/availability",
-		{ items },
-	);
+	const { availability } = await useRevenexxSdk().inventories.inventoriesAvailability({
+		items: items as Models.InventoryAvailabilityItem[],
+	}) as unknown as { availability: ItemAvailability[] };
 	const byKey = new Map<string, ItemAvailability>();
 	for (const entry of availability) {
 		if (entry.product_id) byKey.set(entry.product_id, entry);

package/server/utils/liveOrders.ts

@@ -129,11 +129,13 @@ export function mapLiveOrderToAccount(order: LiveOrder): AccountOrder {
 
 /** Fetch one live order by its display number (the account history id). */
 export async function getLiveOrderByNumber(number: string): Promise<LiveOrder | null> {
-	const api = useRevenexxApi();
-	const { items } = await api.get<{ items: LiveOrder[] }>("/v1/orders", { number, limit: 1 });
+	const sdk = useRevenexxSdk();
+	// Raw call: orders.list does not declare its query parameters in the
+	// contract yet, so the generated ordersList() cannot filter by number.
+	const { items } = await sdk.call<{ items: LiveOrder[] }>("GET", "/v1/orders", { query: { number, limit: 1 } });
 	const row = items[0];
 	if (!row) {
 		return null;
 	}
-	return api.get<LiveOrder>(`/v1/orders/${row.id}`);
+	return await sdk.orders.ordersGet({ id: row.id }) as unknown as LiveOrder;
 }

package/server/utils/livePrices.ts

@@ -1,4 +1,5 @@
 import type { H3Event } from "h3";
+import type { Models } from "@revenexx/sdk";
 
 import type { StoredSession } from "../../app/interfaces/auth";
 import type { Product } from "../../app/composables/useProducts";
@@ -21,7 +22,7 @@ interface ResolvedPrice {
 }
 
 /** The buyer's price scope from the session (guests resolve openly). */
-function priceContext(event: H3Event): { contact_id?: string; organization_id?: string } {
+function priceContext(event: H3Event): { contactId?: string; organizationId?: string } {
 	const raw = getCookie(event, SESSION_COOKIE_NAME);
 	if (!raw) {
 		return {};
@@ -29,8 +30,8 @@ function priceContext(event: H3Event): { contact_id?: string; organization_id?:
 	try {
 		const parsed = JSON.parse(raw) as StoredSession;
 		return {
-			...(parsed.contactId ? { contact_id: parsed.contactId } : {}),
-			...(parsed.organizationId ? { organization_id: parsed.organizationId } : {}),
+			...(parsed.contactId ? { contactId: parsed.contactId } : {}),
+			...(parsed.organizationId ? { organizationId: parsed.organizationId } : {}),
 		};
 	}
 	catch {
@@ -61,10 +62,10 @@ export async function enrichProductsWithLivePrices(event: H3Event, products: Pro
 	if (products.length === 0) {
 		return products;
 	}
-	const { prices } = await useRevenexxApi().post<{ prices: ResolvedPrice[] }>("/v1/prices/resolve", {
-		items: products.map(p => ({ product_id: p.id, sku: p.sku, quantity: 1 })),
+	const { prices } = await useRevenexxSdk().prices.pricesResolve({
+		items: products.map(p => ({ product_id: p.id, sku: p.sku, quantity: 1 })) as Models.PriceResolveItem[],
 		...priceContext(event),
-	});
+	}) as unknown as { prices: ResolvedPrice[] };
 
 	const byKey = new Map<string, ResolvedPrice>();
 	for (const price of prices) {
@@ -84,10 +85,10 @@ export async function enrichDetailWithLivePrices(event: H3Event, detail: Product
 	if (!product) {
 		return detail;
 	}
-	const { prices } = await useRevenexxApi().post<{ prices: ResolvedPrice[] }>("/v1/prices/resolve", {
-		items: [{ product_id: product.id, sku: product.sku, quantity: 1 }],
+	const { prices } = await useRevenexxSdk().prices.pricesResolve({
+		items: [{ product_id: product.id, sku: product.sku, quantity: 1 }] as Models.PriceResolveItem[],
 		...priceContext(event),
-	});
+	}) as unknown as { prices: ResolvedPrice[] };
 	const resolved = prices[0];
 	return { ...detail, prices: resolved ? toPriceMap(resolved) : [] };
 }