@revenexx/cover 0.1.0

package/server/api/typesense/drop.get.ts

@@ -0,0 +1,22 @@
+const COLLECTION_NAME = "products";
+
+export default defineEventHandler(async () => {
+	const ts = useTypesense();
+
+	try {
+		const collections = await ts.collections().retrieve();
+		const exists = collections.some(c => c.name === COLLECTION_NAME);
+
+		if (!exists) {
+			return { deleted: false, message: `Collection '${COLLECTION_NAME}' does not exist.` };
+		}
+
+		await ts.collections(COLLECTION_NAME).delete();
+
+		return { deleted: true, message: `Collection '${COLLECTION_NAME}' deleted.` };
+	}
+	catch (err) {
+		getLogService().error("Typesense error: drop", toErrorContext(err));
+		throw createError({ statusCode: 503, message: "Search service unavailable" });
+	}
+});

package/server/api/typesense/health.get.ts

@@ -0,0 +1,9 @@
+export default defineEventHandler(async () => {
+	try {
+		return await useTypesense().health.retrieve();
+	}
+	catch (err) {
+		getLogService().error("Typesense error: health", toErrorContext(err));
+		throw createError({ statusCode: 503, message: "Search service unavailable" });
+	}
+});

package/server/api/typesense/search.post.ts

@@ -0,0 +1,199 @@
+import type { ProductList } from "../../../app/interfaces/product-list";
+import type { SearchFacet } from "../../../app/interfaces/search-facets";
+
+import { FACET_FIELDS, PRODUCTS_COLLECTION } from "../../utils/productsSchema";
+
+type SortOption = "relevance" | "price_asc" | "price_desc" | "name_asc" | "name_desc";
+
+const SORT_MAP: Record<SortOption, string> = {
+	relevance: "_text_match:desc",
+	price_asc: "price:asc",
+	price_desc: "price:desc",
+	name_asc: "name:asc",
+	name_desc: "name:desc",
+};
+
+interface SearchBody {
+	q: string;
+	filters?: Record<string, string[]>;
+	priceRange?: { min?: number; max?: number };
+	sort?: SortOption;
+	page?: number;
+	perPage?: number;
+}
+
+export default defineEventHandler(async (event) => {
+	const {
+		q,
+		filters,
+		priceRange,
+		sort = "relevance",
+		page = 1,
+		perPage = 20,
+	} = await readBody<SearchBody>(event);
+
+	if (!q?.trim()) {
+		return null;
+	}
+
+	// Live mode searches the platform's real Typesense index through the
+	// public API. The live collection has no price/stock fields (yet), so
+	// price filters and price sorts degrade to relevance gracefully.
+	if (resolveProductServiceKey(event) === "api") {
+		const locale = resolveLocale(event);
+		const liveFilterParts = [`locale:=${tsFilterValue(locale)}`, "enabled:=true"];
+
+		if (filters) {
+			// The storefront filters with the demo-schema field names; the
+			// live collection (search.json) names them differently. Category
+			// slugs ARE the live category codes, but products carry their
+			// LEAF code only — a top-level category expands to its children.
+			// Unknown fields are dropped instead of 400ing the request.
+			const categoryCodes: string[] = [];
+			const tree = await getLiveCategories(locale);
+
+			for (const [field, values] of Object.entries(filters)) {
+				if (!values?.length) {
+					continue;
+				}
+				if (field === "categorySlug" || field === "subcategorySlug" || field === "categories") {
+					for (const value of values) {
+						const node = tree.find(c => c.slug === value);
+						categoryCodes.push(value, ...(node?.subcategories.map(s => s.slug) ?? []));
+					}
+				}
+				else if (field === "manufacturer" || field === "kind") {
+					liveFilterParts.push(`${field}:=[${values.map(v => tsFilterValue(v)).join(",")}]`);
+				}
+				else if (field === "available" || field === "enabled") {
+					// enabled:=true is already pinned; an explicit "false" can
+					// never match — keep the pinned filter authoritative.
+				}
+			}
+
+			if (categoryCodes.length) {
+				liveFilterParts.push(`categories:=[${[...new Set(categoryCodes)].map(tsFilterValue).join(",")}]`);
+			}
+		}
+
+		try {
+			const results = await searchLiveProducts({
+				q,
+				queryBy: "name,sku,description,manufacturer",
+				filterBy: liveFilterParts.join(" && "),
+				// category_labels is a locale-templated field and not a facet in
+				// the deployed schema — categories (codes) is the stable facet.
+				facetBy: "manufacturer,kind,categories",
+				page,
+				perPage,
+			});
+
+			let products: ProductList[] = (results.hits ?? []).map(hit => mapLiveDocToProduct(hit.document));
+			if (resolvePriceServiceKey(event) === "api") {
+				products = await enrichProductsWithLivePrices(event, products);
+			}
+			if (resolveInventoryServiceKey(event) === "api") {
+				products = await enrichProductsWithLiveAvailability(event, products);
+			}
+			const facets: SearchFacet[] = (results.facet_counts ?? []).map(fc => ({
+				fieldName: fc.field_name,
+				counts: (fc.counts ?? []).map(c => ({ value: c.value, count: c.count })),
+			}));
+
+			return {
+				products,
+				facets,
+				found: results.found,
+				page: results.page ?? page,
+				perPage,
+			};
+		}
+		catch (err) {
+			getLogService().error("API error: search", apiErrorContext(err));
+			throw createError({ statusCode: 503, message: "Search service unavailable" });
+		}
+	}
+
+	const ts = useTypesense();
+
+	const filterParts: string[] = [];
+
+	if (filters) {
+		for (const [field, values] of Object.entries(filters)) {
+			if (values?.length) {
+				const isBool = values.every(v => v === "true" || v === "false");
+				const joined = isBool
+					? values.join(",")
+					: values.map(v => `\`${v}\``).join(",");
+				filterParts.push(`${field}:=[${joined}]`);
+			}
+		}
+	}
+
+	// priceRange values are in euros; multiply by 100 to match stored cents
+	if (priceRange?.min !== undefined) {
+		filterParts.push(`price:>=${priceRange.min * 100}`);
+	}
+	if (priceRange?.max !== undefined) {
+		filterParts.push(`price:<=${priceRange.max * 100}`);
+	}
+
+	const sortBy = SORT_MAP[sort] ?? SORT_MAP.relevance;
+
+	try {
+		const results = await ts.collections(PRODUCTS_COLLECTION).documents().search({
+			q,
+			query_by: "name,sku",
+			facet_by: FACET_FIELDS.join(","),
+			num_typos: 2,
+			...(filterParts.length ? { filter_by: filterParts.join(" && ") } : {}),
+			sort_by: sortBy,
+			page,
+			per_page: perPage,
+		});
+
+		// The index stores a flattened document (prices as one map, taxRate
+		// and stockQuantity as scalars) — normalize back to the ProductList
+		// contract here so cards can price, tax and add-to-cart the hits.
+		const products: ProductList[] = (results.hits ?? []).map((hit) => {
+			const doc = hit.document as unknown as Omit<ProductList, "id" | "prices" | "tax"> & {
+				id: string;
+				prices?: Record<string, number> | Record<string, number>[];
+				taxRate?: number;
+				stockQuantity?: number;
+			};
+			const prices = Array.isArray(doc.prices)
+				? doc.prices
+				: doc.prices
+					? [doc.prices]
+					: [];
+			return {
+				...doc,
+				id: String(doc.id),
+				prices,
+				tax: { rate: doc.taxRate ?? 19 },
+				isOutOfStock: (doc.stockQuantity ?? 0) <= 0,
+			};
+		});
+
+		const facets: SearchFacet[] = (results.facet_counts ?? []).map(fc => ({
+			fieldName: fc.field_name,
+			counts: (fc.counts ?? []).map(c => ({
+				value: c.value,
+				count: c.count,
+			})),
+		}));
+
+		return {
+			products,
+			facets,
+			found: results.found,
+			page: results.page ?? page,
+			perPage,
+		};
+	}
+	catch (err) {
+		getLogService().error("Typesense error: search", toErrorContext(err));
+		throw createError({ statusCode: 503, message: "Search service unavailable" });
+	}
+});

package/server/api/typesense/seed.get.ts

@@ -0,0 +1,112 @@
+import productsData from "../../data/product-list.json";
+import { PRODUCTS_COLLECTION, productsSchema } from "../../utils/productsSchema";
+
+const MAX_COUNT = 5000;
+
+function mapEntry(entry: (typeof productsData)[number], idOffset: number) {
+	const product = entry.product[0];
+	const stock = entry.stocks[0];
+	const prices = entry.prices[0] as Record<string, number>;
+	const longDescription = entry.descriptions.find(d => d.type === "long");
+	const mainCategory = entry.categories.find(c => c.type === "main");
+	const subcategory = entry.categories.find(c => c.type === "subcategory");
+	const slugCategory = entry.categories.find(c => c.type === "slug");
+	const mainImage = entry.images.find(i => i.priority === 1);
+	const basePrice = prices["1"] ?? Object.values(prices)[0] ?? 0;
+
+	const slugPath = slugCategory?.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 id = idOffset === 0 ? product.id : product.id + idOffset * 100_000;
+	const suffix = idOffset === 0 ? "" : ` #${idOffset}`;
+
+	return {
+		id: String(id),
+		name: `${product.name}${suffix}`,
+		sku: idOffset === 0 ? product.sku : `${product.sku}-${idOffset}`,
+		manufacturer: product.manufacturer,
+		available: stock.quantity > 0,
+		stockQuantity: stock.quantity,
+		price: basePrice,
+		prices,
+		description: longDescription?.content,
+		category: mainCategory?.name ?? "",
+		categorySlug,
+		subcategory: subcategory?.name,
+		...(subcategorySlug ? { subcategorySlug } : {}),
+		slug: idOffset === 0 ? slugPath : `${slugPath}-${idOffset}`,
+		image: mainImage?.url,
+		taxRate: entry.tax.rate,
+	};
+}
+
+export default defineEventHandler(async (event) => {
+	const query = getQuery(event);
+	const requestedCount = parseInt(String(query.count ?? "0"), 10);
+	const targetCount = requestedCount > 0
+		? Math.min(requestedCount, MAX_COUNT)
+		: productsData.length;
+
+	const ts = useTypesense();
+
+	try {
+		const collections = await ts.collections().retrieve();
+		const exists = collections.some(c => c.name === PRODUCTS_COLLECTION);
+		if (exists) {
+			await ts.collections(PRODUCTS_COLLECTION).delete();
+		}
+
+		await ts.collections().create(productsSchema);
+	}
+	catch (err) {
+		getLogService().error("Typesense error: seed collection setup", toErrorContext(err));
+		throw createError({ statusCode: 503, message: "Search service unavailable" });
+	}
+
+	const documents: ReturnType<typeof mapEntry>[] = [];
+	let idOffset = 0;
+
+	while (documents.length < targetCount) {
+		for (const entry of productsData) {
+			if (documents.length >= targetCount) {
+				break;
+			}
+			documents.push(mapEntry(entry, idOffset));
+		}
+		idOffset++;
+	}
+
+	let result: { success: boolean; error?: string; document?: unknown }[] = [];
+
+	try {
+		result = await ts.collections(PRODUCTS_COLLECTION).documents().import(
+			documents,
+			{ action: "upsert" },
+		);
+	}
+	catch (e: unknown) {
+		if (e && typeof e === "object" && "importResults" in e) {
+			result = (e as { importResults: typeof result }).importResults;
+		}
+		else {
+			getLogService().error("Typesense error: seed import", toErrorContext(e));
+			throw e;
+		}
+	}
+
+	const failed = result.filter(r => !r.success);
+
+	return {
+		total: documents.length,
+		indexed: documents.length - failed.length,
+		failed: failed.length,
+		errors: failed,
+	};
+});

package/server/api/typesense/suggest.post.ts

@@ -0,0 +1,69 @@
+export default defineEventHandler(async (event) => {
+	const { q } = await readBody<{ q: string }>(event);
+
+	if (!q?.trim()) {
+		return { suggestions: [] };
+	}
+
+	// Live mode queries the platform's real Typesense index through the
+	// public API; the local docker index stays the mock implementation.
+	if (resolveProductServiceKey(event) === "api") {
+		const locale = resolveLocale(event);
+		try {
+			const results = await searchLiveProducts({
+				q,
+				queryBy: "name,sku",
+				filterBy: `locale:=${tsFilterValue(locale)} && enabled:=true`,
+				perPage: 6,
+			});
+
+			return {
+				suggestions: (results.hits ?? []).map((hit) => {
+					const doc = hit.document;
+					return {
+						id: doc.entity_id,
+						name: doc.name,
+						sku: doc.sku,
+						category: doc.category_labels?.[0] ?? doc.categories?.[0] ?? "",
+						categorySlug: doc.categories?.[0] ?? "",
+						subcategorySlug: undefined,
+					};
+				}),
+			};
+		}
+		catch (err) {
+			getLogService().error("API error: suggest", apiErrorContext(err));
+			throw createError({ statusCode: 503, message: "Search service unavailable" });
+		}
+	}
+
+	const ts = useTypesense();
+
+	try {
+		const results = await ts.collections("products").documents().search({
+			q,
+			query_by: "name,sku",
+			per_page: 6,
+			prefix: true,
+			num_typos: 2,
+		});
+
+		return {
+			suggestions: (results.hits ?? []).map((hit) => {
+				const doc = hit.document as Record<string, unknown>;
+				return {
+					id: String(doc.id),
+					name: doc.name as string,
+					sku: doc.sku as string,
+					category: doc.category as string,
+					categorySlug: doc.categorySlug as string,
+					subcategorySlug: doc.subcategorySlug as string | undefined,
+				};
+			}),
+		};
+	}
+	catch (err) {
+		getLogService().error("Typesense error: suggest", toErrorContext(err));
+		throw createError({ statusCode: 503, message: "Search service unavailable" });
+	}
+});

package/server/config/account/organization.json

@@ -0,0 +1,146 @@
+{
+	"name": "Demo GmbH",
+	"settings": {
+		"costCenters": {
+			"enabled": true,
+			"required": false
+		},
+		"workflows": {
+			"enabled": true
+		},
+		"cart": {
+			"exportEnabled": true,
+			"priceDisplay": "net",
+			"minOrderValue": 250,
+			"multipleCarts": true
+		},
+		"approvals": {
+			"enabled": true
+		},
+		"checkout": {
+			"guestOrdering": {
+				"b2b": true,
+				"b2c": true
+			},
+			"orderNumberRequired": false
+		}
+	},
+	"costCenters": [
+		{
+			"id": "cc-1",
+			"code": "CC-100",
+			"label": "Marketing"
+		},
+		{
+			"id": "cc-2",
+			"code": "CC-200",
+			"label": "Engineering",
+			"limit": {
+				"id": "lim-cc-2",
+				"type": "budget",
+				"subject": {
+					"type": "cost-center",
+					"costCenterId": "cc-2"
+				},
+				"label": "Kostenstellen-Budget Engineering",
+				"totalBudget": 2000,
+				"availableBudget": 450,
+				"currency": "EUR",
+				"active": true,
+				"approval": {
+					"required": true,
+					"approverId": "persona-approver",
+					"approverName": "Achim Approver",
+					"deputyId": "persona-admin",
+					"deputyName": "Ada Admin",
+					"deputyTimeLimitHours": 24,
+					"timeLimitHours": 48
+				}
+			}
+		},
+		{
+			"id": "cc-3",
+			"code": "CC-300",
+			"label": "Operations"
+		},
+		{
+			"id": "cc-4",
+			"code": "CC-400",
+			"label": "Vertrieb Außendienst",
+			"limit": {
+				"id": "lim-cc-4",
+				"type": "budget",
+				"subject": {
+					"type": "cost-center",
+					"costCenterId": "cc-4"
+				},
+				"label": "Budget Vertrieb Außendienst",
+				"totalBudget": 15000,
+				"availableBudget": 11200,
+				"currency": "EUR",
+				"active": true,
+				"approval": {
+					"required": true,
+					"approverId": "persona-admin",
+					"approverName": "Ada Admin",
+					"timeLimitHours": 72
+				}
+			}
+		},
+		{
+			"id": "cc-5",
+			"code": "CC-500",
+			"label": "IT & Infrastruktur",
+			"limit": {
+				"id": "lim-cc-5",
+				"type": "budget",
+				"subject": {
+					"type": "cost-center",
+					"costCenterId": "cc-5"
+				},
+				"label": "IT-Budget Q2",
+				"totalBudget": 25000,
+				"availableBudget": 3100,
+				"currency": "EUR",
+				"active": true,
+				"approval": {
+					"required": true,
+					"approverId": "persona-approver",
+					"approverName": "Achim Approver",
+					"deputyId": "persona-admin",
+					"deputyName": "Ada Admin",
+					"deputyTimeLimitHours": 24,
+					"timeLimitHours": 24
+				}
+			}
+		},
+		{
+			"id": "cc-6",
+			"code": "CC-600",
+			"label": "Fuhrpark"
+		},
+		{
+			"id": "cc-7",
+			"code": "CC-700",
+			"label": "Arbeitssicherheit",
+			"limit": {
+				"id": "lim-cc-7",
+				"type": "budget",
+				"subject": {
+					"type": "cost-center",
+					"costCenterId": "cc-7"
+				},
+				"label": "Budget Arbeitssicherheit",
+				"totalBudget": 8000,
+				"availableBudget": 7650,
+				"currency": "EUR",
+				"active": true,
+				"approval": {
+					"required": false,
+					"approverId": "persona-admin",
+					"approverName": "Ada Admin"
+				}
+			}
+		}
+	]
+}