// @vitest-environment node import { createHash } from "node:crypto"; import type { DbClient } from "@hivegrid/db/client.server"; import { customerPortalCommercialProducts, entitlementLimitTypes, featureKeys, getFeatureGate, standardEntitlementPlans, type EntitlementPlanId, } from "@hivegrid/entitlements"; import { describe, expect, it, vi } from "vitest"; import { assessDatabaseCatalog, buildCustomerPortalCatalogPlan, customerPortalCatalogPlanIsBlocked, customerPortalCatalogPlanIsComplete, LagoCatalogClient, planProviderCatalog, reconcileBasePlanPortalFeatures, type DatabaseCatalogSnapshot, type DatabaseBasePlanSnapshot, type DatabaseProductSnapshot, type ProviderCatalogSnapshot, } from "./catalog"; const testLagoOrganizationId = "test-staging-organization-id"; const testLagoIdentity = { expectedOrganizationIdSha256: createHash("sha256").update(testLagoOrganizationId).digest("hex"), }; function lagoOrganizationResponse(name = "HiveGrid Staging", id = testLagoOrganizationId): Response { return Response.json({ organization: { lago_id: id, name } }); } function providerSnapshot(): ProviderCatalogSnapshot { return { plan: { code: "customer_portal_monthly", name: "Customer Portal", description: customerPortalCommercialProducts.monthlyAddOn.description, interval: "monthly", amount_cents: 1_999, amount_currency: "EUR", pay_in_advance: true, taxes: [{ code: "de-vat-19" }], }, addOn: { code: "customer_portal_domain_setup", name: "Customer Portal Domain Setup", description: customerPortalCommercialProducts.customDomainSetup.description, amount_cents: 29_999, amount_currency: "EUR", taxes: [{ code: "de-vat-19" }], }, }; } function commercialProduct(definition: (typeof customerPortalCommercialProducts)[keyof typeof customerPortalCommercialProducts]): DatabaseProductSnapshot { return { billingProviderId: `hivegrid_commercial_product_${definition.code}`, code: definition.code, title: definition.title, description: definition.description, kind: definition.source, order: definition.catalogOrder, model: 0, active: true, public: definition.public, groupTitle: "Customer Portal", groupDescription: null, badge: null, billingAddressCollection: "auto", hasQuantity: false, canBuyAgain: definition.source === "one_time_setup", lagoPlanCode: definition.source === "recurring_add_on" ? definition.code : null, features: definition.featureKeys.map((name, index) => ({ order: index + 1, title: getFeatureGate(name)!.title, name, code: null, type: entitlementLimitTypes.included, value: definition.includedQuantity ?? entitlementLimitTypes.included, quotaValue: null, href: null, badge: getFeatureGate(name)!.title, accumulate: false, })), prices: definition.amountCents === null || definition.currency === null ? [] : [ { billingProviderId: `hivegrid_commercial_price_${definition.code}`, lagoFeeCode: definition.code, molliePriceReference: `hivegrid_commercial_price_${definition.code}`, type: definition.source === "recurring_add_on" ? 1 : 0, billingPeriod: definition.source === "recurring_add_on" ? 3 : 0, price: (definition.amountCents / 100).toFixed(2), currency: definition.currency.toLowerCase(), trialDays: 0, active: true, }, ], }; } function databaseSnapshot(): DatabaseCatalogSnapshot { return { commercialProducts: Object.values(customerPortalCommercialProducts).map(commercialProduct), basePlans: [basePlan("starter"), basePlan("pro"), basePlan("business")], }; } function basePlan(planCode: EntitlementPlanId): DatabaseBasePlanSnapshot { const plan = standardEntitlementPlans.find((candidate) => candidate.id === planCode)!; const feature = plan.features.find((candidate) => candidate.featureKey === featureKeys.customerPortal)!; return { id: `${planCode}-product-id`, code: planCode, kind: "base_plan", portalFeatures: [ { order: Math.round(feature.order), title: feature.label, name: feature.featureKey, code: null, type: feature.limitType, value: feature.limit ?? feature.limitType, quotaValue: null, href: null, badge: getFeatureGate(featureKeys.customerPortal)!.title, accumulate: feature.limitType === entitlementLimitTypes.monthly, }, ], }; } describe("customer-portal catalog plan", () => { it("recognizes the canonical provider and database state", () => { const plan = buildCustomerPortalCatalogPlan(providerSnapshot(), databaseSnapshot()); expect(customerPortalCatalogPlanIsComplete(plan)).toBe(true); expect(customerPortalCatalogPlanIsBlocked(plan)).toBe(false); }); it("creates missing resources, safely updates tax-only drift, and blocks commercial provider drift", () => { expect(planProviderCatalog({ plan: null, addOn: null }).map((action) => action.action)).toEqual(["create", "create"]); const missingTax = providerSnapshot(); missingTax.plan!.taxes = []; missingTax.addOn!.taxes = []; expect(planProviderCatalog(missingTax)).toEqual([ expect.objectContaining({ action: "update", driftFields: ["taxCodes"] }), expect.objectContaining({ action: "update", driftFields: ["taxCodes"] }), ]); const drifted = providerSnapshot(); drifted.plan!.amount_cents = 1; const actions = planProviderCatalog(drifted); expect(actions[0]).toMatchObject({ action: "drift", driftFields: ["amountCents"] }); }); it("distinguishes reconcilable commercial rows from a safely missing base-plan portal feature", () => { const missing = databaseSnapshot(); const reconcilable = assessDatabaseCatalog({ ...missing, commercialProducts: missing.commercialProducts.slice(1) }); expect(reconcilable.reconcileIssues).toContain("customer_portal_monthly: product missing"); expect(reconcilable.blockingIssues).toEqual([]); const missingFeature = databaseSnapshot(); const baseFeatureReconciliation = assessDatabaseCatalog({ ...missingFeature, basePlans: missingFeature.basePlans.map((plan) => (plan.code === "business" ? { ...plan, portalFeatures: [] } : plan)), }); expect(baseFeatureReconciliation.reconcileIssues).toContain("business: canonical customer_portal feature missing"); expect(baseFeatureReconciliation.blockingIssues).toEqual([]); }); it("blocks a missing base-plan product and never invents a replacement", () => { const snapshot = databaseSnapshot(); const assessment = assessDatabaseCatalog({ ...snapshot, basePlans: snapshot.basePlans.filter((plan) => plan.code !== "business"), }); expect(assessment.blockingIssues).toContain("business: expected exactly one canonical base-plan product"); expect(assessment.reconcileIssues).not.toContain("business: canonical customer_portal feature missing"); const duplicateAssessment = assessDatabaseCatalog({ ...snapshot, basePlans: [...snapshot.basePlans, basePlan("business")], }); expect(duplicateAssessment.blockingIssues).toContain("business: expected exactly one canonical base-plan product"); }); it("blocks an existing wrong or duplicate portal feature instead of updating or deleting it", () => { const snapshot = databaseSnapshot(); const business = snapshot.basePlans.find((plan) => plan.code === "business")!; const wrongFeature = { ...business, portalFeatures: business.portalFeatures.map((feature) => ({ ...feature, type: entitlementLimitTypes.notIncluded, value: 0 })), }; const wrongAssessment = assessDatabaseCatalog({ ...snapshot, basePlans: snapshot.basePlans.map((plan) => (plan === business ? wrongFeature : plan)), }); expect(wrongAssessment.blockingIssues).toContain("business: existing customer_portal feature differs from the canonical contract"); const duplicateAssessment = assessDatabaseCatalog({ ...snapshot, basePlans: snapshot.basePlans.map((plan) => plan === business ? { ...business, portalFeatures: [...business.portalFeatures, ...business.portalFeatures] } : plan ), }); expect(duplicateAssessment.blockingIssues).toContain("business: duplicate customer_portal feature rows"); }); it("creates only a missing canonical portal feature and leaves every other plan feature untouched", async () => { const snapshot = databaseSnapshot(); const baseProducts = snapshot.basePlans.map((plan) => ({ id: plan.id, code: plan.code, kind: "base_plan", features: plan.code === "business" ? [] : plan.portalFeatures, prices: [], })); const create = vi.fn().mockResolvedValue({}); const db = { subscriptionProduct: { findMany: vi.fn().mockResolvedValue(baseProducts) }, subscriptionFeature: { create }, } as unknown as DbClient; await expect(reconcileBasePlanPortalFeatures(db)).resolves.toEqual(["business"]); expect(create).toHaveBeenCalledTimes(1); expect(create).toHaveBeenCalledWith({ data: expect.objectContaining({ subscriptionProductId: "business-product-id", order: Math.round( standardEntitlementPlans .find((candidate) => candidate.id === "business")! .features.find((candidate) => candidate.featureKey === featureKeys.customerPortal)!.order ), name: featureKeys.customerPortal, type: entitlementLimitTypes.included, value: entitlementLimitTypes.included, }), }); }); it("blocks a title collision that the shared seed helper could otherwise take over", () => { const snapshot = databaseSnapshot(); const monthly = snapshot.commercialProducts.find((product) => product.code === "customer_portal_monthly")!; const collision = { ...monthly, billingProviderId: "legacy-product", code: "legacy_customer_portal" }; const assessment = assessDatabaseCatalog({ ...snapshot, commercialProducts: [collision, ...snapshot.commercialProducts.filter((product) => product !== monthly)], }); expect(assessment.blockingIssues).toContain("customer_portal_monthly: existing seed-key collision would mutate another product"); }); it("does not report checkout-relevant product or price drift as complete", () => { const snapshot = databaseSnapshot(); const monthly = snapshot.commercialProducts.find((product) => product.code === "customer_portal_monthly")!; const driftedMonthly = { ...monthly, canBuyAgain: true, prices: monthly.prices.map((price) => ({ ...price, molliePriceReference: "wrong-reference", trialDays: 14 })), }; const assessment = assessDatabaseCatalog({ ...snapshot, commercialProducts: snapshot.commercialProducts.map((product) => (product === monthly ? driftedMonthly : product)), }); expect(assessment.reconcileIssues).toEqual( expect.arrayContaining(["customer_portal_monthly: product metadata differs", "customer_portal_monthly: canonical price contract differs"]) ); }); it("does not report commercial feature property drift as complete", () => { const snapshot = databaseSnapshot(); const monthly = snapshot.commercialProducts.find((product) => product.code === "customer_portal_monthly")!; const driftedMonthly = { ...monthly, features: monthly.features.map((feature, index) => index === 0 ? { ...feature, order: 99, title: "Wrong", type: entitlementLimitTypes.notIncluded, value: 0, badge: null, accumulate: true } : feature ), }; const assessment = assessDatabaseCatalog({ ...snapshot, commercialProducts: snapshot.commercialProducts.map((product) => (product === monthly ? driftedMonthly : product)), }); expect(assessment.reconcileIssues).toContain("customer_portal_monthly: feature contract differs"); }); it("blocks additional active prices that the shared seed helper cannot remove", () => { const snapshot = databaseSnapshot(); const monthly = snapshot.commercialProducts.find((product) => product.code === "customer_portal_monthly")!; const withUnexpectedActivePrice = { ...monthly, prices: [...monthly.prices, { ...monthly.prices[0]!, billingPeriod: 4, billingProviderId: "unexpected-yearly", lagoFeeCode: "unexpected-yearly" }], }; const assessment = assessDatabaseCatalog({ ...snapshot, commercialProducts: snapshot.commercialProducts.map((product) => (product === monthly ? withUnexpectedActivePrice : product)), }); expect(assessment.blockingIssues).toContain("customer_portal_monthly: unexpected active price cannot be removed by reconciliation"); }); }); describe("Lago customer-portal catalog client", () => { it("treats 404 reads as missing without leaking credentials", async () => { const fetchImpl = vi .fn() .mockImplementation(async (url) => (String(url).endsWith("/organizations") ? lagoOrganizationResponse() : new Response(null, { status: 404 }))); const client = new LagoCatalogClient({ apiUrl: "https://lago.example.test", apiKey: "secret-key", fetchImpl }, testLagoIdentity); await expect(client.readCatalog()).resolves.toEqual({ plan: null, addOn: null }); for (const call of fetchImpl.mock.calls) { expect(String(call[0])).not.toContain("secret-key"); expect(new Headers(call[1]?.headers).get("authorization")).toBe("Bearer secret-key"); } }); it("creates and updates the exact taxed recurring plan and one-time add-on contracts", async () => { const fetchImpl = vi.fn().mockImplementation(async (url, init) => { if (String(url).endsWith("/organizations")) return lagoOrganizationResponse(); const body = JSON.parse(String(init?.body)) as { plan?: unknown; add_on?: unknown }; if (body.plan) return Response.json({ plan: providerSnapshot().plan }); return Response.json({ add_on: providerSnapshot().addOn }); }); const client = new LagoCatalogClient({ apiUrl: "https://lago.example.test", apiKey: "secret-key", fetchImpl }, testLagoIdentity); await client.createPlan(); await client.createAddOn(); await client.updatePlan(); await client.updateAddOn(); expect(JSON.parse(String(fetchImpl.mock.calls[1]?.[1]?.body))).toEqual({ plan: expect.objectContaining({ code: "customer_portal_monthly", interval: "monthly", amount_cents: 1_999, pay_in_advance: true, tax_codes: ["de-vat-19"], }), }); expect(JSON.parse(String(fetchImpl.mock.calls[3]?.[1]?.body))).toEqual({ add_on: expect.objectContaining({ code: "customer_portal_domain_setup", amount_cents: 29_999, amount_currency: "EUR", tax_codes: ["de-vat-19"], }), }); expect(fetchImpl.mock.calls[5]?.[1]?.method).toBe("PUT"); expect(JSON.parse(String(fetchImpl.mock.calls[5]?.[1]?.body))).toEqual({ plan: expect.objectContaining({ code: "customer_portal_monthly", tax_codes: ["de-vat-19"] }), }); expect(fetchImpl.mock.calls[7]?.[1]?.method).toBe("PUT"); expect(JSON.parse(String(fetchImpl.mock.calls[7]?.[1]?.body))).toEqual({ add_on: expect.objectContaining({ code: "customer_portal_domain_setup", tax_codes: ["de-vat-19"] }), }); }); it.each([ ["different name", "HiveGrid Production", testLagoOrganizationId], ["different id fingerprint", "HiveGrid Staging", "different-organization-id"], ])("rejects a Lago organization with a %s before catalog reads or mutations", async (_label, name, id) => { const fetchImpl = vi.fn().mockResolvedValue(lagoOrganizationResponse(name, id)); const client = new LagoCatalogClient({ apiUrl: "https://lago.example.test", apiKey: "secret-key", fetchImpl }, testLagoIdentity); await expect(client.readCatalog()).rejects.toThrow("Lago organization does not match the canonical staging identity"); expect(fetchImpl).toHaveBeenCalledTimes(1); }); });