Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/scripts/customer-portal-uat/commercial-fixture.ts
T

2025 lines
82 KiB
TypeScript

import { hashCurrentPassword, verifySupportedPassword } from "../../apps/api/src/auth/password";
import { createHash } from "node:crypto";
import { isDeepStrictEqual } from "node:util";
import { publishAuditEventViaOutbox } from "@hivegrid/db/audit-events.server";
import type { DbClient } from "@hivegrid/db/client.server";
import { runWithRlsContext } from "@hivegrid/db/rls-context.server";
import { customerPortalCommercialProducts } from "@hivegrid/entitlements";
import { grantContractProductAcquisition, type ProductAcquisitionClient } from "../../apps/web/app/services/billing/product-acquisition.server";
import {
getCustomerPortalCommercialEligibility,
grantEnterpriseCustomerPortalContract,
portalEnterpriseClaimScopeKey,
type CustomerPortalCommercialEligibility,
} from "../../apps/web/app/services/customer-portal/portal-domain-commercial.server";
import {
CUSTOMER_PORTAL_UAT_ADMIN_EMAIL,
CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG,
CUSTOMER_PORTAL_UAT_STARTER_TENANT_SLUG,
CUSTOMER_PORTAL_UAT_TENANT_SLUG,
CustomerPortalUatError,
type CustomerPortalCommercialFixtureCommand,
} from "./contracts";
const UAT_ADMIN_USER_ID = "customer-portal-uat-tenant-admin";
const UAT_ROLE_NAME = "Customer Portal UAT Admin";
const UAT_ROLE_DESCRIPTION = "Dedicated VA-P26c staging UAT role. Not for real workspace members.";
const UAT_PORTAL_MARKER = "VA-P26c-commercial";
const UAT_ENTERPRISE_TENANT_NAME = "Demo Enterprise CRM";
const UAT_ENTERPRISE_SUBSCRIPTION_ID = "customer-portal-uat-enterprise-subscription";
const UAT_ENTERPRISE_BASE_PRODUCT_ID = "customer-portal-uat-enterprise-base-product";
const UAT_ENTERPRISE_PORTAL_ID = "customer-portal-uat-demo-enterprise-crm";
const UAT_ENTERPRISE_CONFIGURATION_ID = "customer-portal-uat-enterprise-configuration";
const UAT_ENTERPRISE_CONTRACT_REFERENCE = "VA-P26c-UAT-demo-enterprise-crm";
const UAT_ENTERPRISE_SCOPE_KEY = "tenant";
const UAT_ENTERPRISE_AUDIT_ACTION = "billing.product_acquisition.contract_granted";
const UAT_REQUIRED_PERMISSIONS = [
"app.dashboard.view",
"portal.admin",
"portal.read",
"portal.manage_users",
"portal.manage_access",
"portal.activity.read",
"portal.activity.manage",
"crm.read_own",
"projects.read_own",
"projects.read_all",
] as const;
const UAT_LEGAL_ORIGIN = "https://saas-ctrl.com";
type CommercialTenantKind = "starter" | "pro" | "enterprise";
type UatUserSnapshot = {
readonly id: string;
readonly email: string;
readonly firstName: string;
readonly lastName: string;
readonly defaultTenantId: string | null;
readonly active: boolean;
readonly pendingDeletion: boolean;
readonly pseudonymized: boolean;
readonly hasPlatformAdmin: boolean;
readonly passwordMatches: boolean;
};
type UatTenantSnapshot = {
readonly kind: CommercialTenantKind;
readonly expectedId: string;
readonly expectedSlug: string;
readonly tenant: {
readonly id: string;
readonly slug: string;
readonly name: string;
readonly active: boolean;
readonly subscription: {
readonly id: string;
readonly planCode: string | null;
readonly seatQuantity: number;
readonly status: string;
readonly billingProviderCustomerId: string | null;
readonly lagoCustomerId: string | null;
readonly mollieCustomerId: string | null;
readonly lastInvoiceExternalId: string | null;
readonly lastPaymentExternalId: string | null;
readonly trialStartsAt: Date | null;
readonly trialEndsAt: Date | null;
readonly pastDueSince: Date | null;
readonly frozenAt: Date | null;
readonly cancelledAt: Date | null;
readonly dunningAttemptCount: number;
readonly lastDunningSentAt: Date | null;
readonly products: readonly {
readonly id: string;
readonly customEntitlementPlanId: string | null;
readonly cancelledAt: Date | null;
readonly endsAt: Date | null;
readonly billingProviderSubscriptionId: string | null;
readonly lagoSubscriptionId: string | null;
readonly planCode: string | null;
readonly seatQuantity: number | null;
readonly quantity: number | null;
readonly fromCheckoutSessionId: string | null;
readonly currentPeriodStart: Date | null;
readonly currentPeriodEnd: Date | null;
readonly prices: readonly { readonly id: string }[];
readonly acquisition: { readonly id: string } | null;
readonly subscriptionProduct: { readonly id: string; readonly code: string | null; readonly kind: string; readonly active: boolean };
}[];
} | null;
} | null;
readonly portal: {
readonly id: string;
readonly subdomain: string;
readonly title: string;
readonly isPublished: boolean;
readonly authRequireEmailVerification: boolean;
readonly authRequireOrganization: boolean;
readonly authRequireName: boolean;
readonly metadata: unknown;
readonly configuration: {
readonly id: string;
readonly enabledProjectTypes: readonly string[];
readonly uploadMaxFiles: number;
readonly uploadMaxFileSizeBytes: number;
readonly statusEmailsEnabled: boolean;
readonly welcomeMessage: string | null;
readonly supportEmail: string | null;
readonly imprintUrl: string | null;
readonly privacyUrl: string | null;
readonly isDemoData: boolean;
} | null;
} | null;
readonly roleCandidates: readonly {
readonly id: string;
readonly tenantId: string | null;
readonly name: string;
readonly description: string;
readonly type: string;
readonly assignToNewUsers: boolean;
readonly isDefault: boolean;
readonly order: number;
readonly permissions: readonly { readonly id: string; readonly permission: { readonly id: string; readonly name: string } }[];
}[];
readonly membershipCandidates: readonly {
readonly id: string;
readonly tenantId: string;
readonly userId: string;
readonly type: number;
readonly joined: number;
readonly status: number;
}[];
readonly assignmentCandidates: readonly {
readonly id: string;
readonly tenantId: string | null;
readonly userId: string;
readonly roleId: string;
}[];
readonly monthlyAcquisitions: readonly {
readonly id: string;
readonly status: string;
readonly subscriptionProduct: { readonly code: string | null };
}[];
readonly enterpriseAcquisitions: readonly {
readonly id: string;
readonly subscriptionProductId: string;
readonly subscriptionPriceId: string | null;
readonly productKind: string;
readonly scopeKey: string;
readonly requestHash: string;
readonly status: string;
readonly version: number;
readonly quantity: number;
readonly amountCents: number | null;
readonly currency: string | null;
readonly checkoutSessionId: string | null;
readonly tenantSubscriptionProductId: string | null;
readonly provider: string | null;
readonly providerPaymentId: string | null;
readonly invoiceExternalId: string | null;
readonly lagoSubscriptionId: string | null;
readonly checkoutUrl: string | null;
readonly sourceReference: string | null;
readonly providerStartedAt: Date | null;
readonly activatedAt: Date | null;
readonly failedAt: Date | null;
readonly cancelledAt: Date | null;
readonly expiredAt: Date | null;
readonly refundedAt: Date | null;
readonly subscriptionProduct: {
readonly id: string;
readonly code: string | null;
readonly kind: string;
readonly active: boolean;
readonly public: boolean;
};
}[];
readonly checkoutSessions: readonly {
readonly id: string;
readonly productKind: string;
readonly subscriptionProductId: string | null;
readonly provider: string | null;
readonly providerPaymentId: string | null;
readonly lagoSubscriptionId: string | null;
readonly checkoutUrl: string | null;
}[];
readonly enterpriseContractClaims: readonly { readonly id: string; readonly billingScopeKey: string | null }[];
readonly commercialEligibility: CustomerPortalCommercialEligibility;
readonly enterpriseGrantAudited: boolean;
};
export type CustomerPortalCommercialFixtureSnapshot = {
readonly userCandidates: readonly UatUserSnapshot[];
readonly permissions: readonly { readonly id: string; readonly name: string }[];
readonly enterpriseProducts: readonly {
readonly id: string;
readonly code: string | null;
readonly kind: string;
readonly active: boolean;
readonly public: boolean;
readonly prices: readonly { readonly id: string }[];
readonly features: readonly { readonly name: string }[];
}[];
readonly starterBaseProducts: readonly {
readonly id: string;
readonly code: string | null;
readonly kind: string;
readonly active: boolean;
}[];
readonly proBaseProducts: readonly {
readonly id: string;
readonly code: string | null;
readonly kind: string;
readonly active: boolean;
}[];
readonly enterpriseTenantCandidates: readonly {
readonly id: string;
readonly slug: string;
readonly name: string;
readonly active: boolean;
}[];
readonly tenants: readonly UatTenantSnapshot[];
};
export type CustomerPortalCommercialFixtureAssessment = {
readonly action: "noop" | "reconcile" | "blocked";
readonly reconcileIssues: readonly string[];
readonly blockingIssues: readonly string[];
readonly liveProof: {
readonly adminEmail: typeof CUSTOMER_PORTAL_UAT_ADMIN_EMAIL;
readonly starterTenantSlug: typeof CUSTOMER_PORTAL_UAT_STARTER_TENANT_SLUG;
readonly proTenantSlug: typeof CUSTOMER_PORTAL_UAT_TENANT_SLUG;
readonly enterpriseTenantSlug: typeof CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG;
readonly starterMonthlyCheckoutReady: boolean;
readonly businessBasePlanReady: boolean;
readonly enterpriseCatalogReady: boolean;
readonly enterpriseContractGrantReady: boolean;
readonly enterprisePortalSource: CustomerPortalCommercialEligibility["portalSource"];
readonly enterpriseDomainSetupIncludedByContract: boolean;
readonly enterpriseCheckoutRows: number;
readonly enterpriseAcquisitionId: string | null;
};
};
function roleId(kind: CommercialTenantKind): string {
return `customer-portal-uat-${kind}-admin-role`;
}
function membershipId(kind: CommercialTenantKind): string {
return `customer-portal-uat-${kind}-membership`;
}
function assignmentId(kind: CommercialTenantKind): string {
return `customer-portal-uat-${kind}-role-assignment`;
}
function isUatPortal(metadata: unknown): boolean {
return typeof metadata === "object" && metadata !== null && "uatFixture" in metadata && metadata.uatFixture === UAT_PORTAL_MARKER;
}
function isDemoProPortal(metadata: unknown): boolean {
return typeof metadata === "object" && metadata !== null && "uatFixture" in metadata && metadata.uatFixture === "VA-P26";
}
function hasProviderIdentity(value: string | null): boolean {
return Boolean(value?.trim());
}
type UatSubscription = NonNullable<NonNullable<UatTenantSnapshot["tenant"]>["subscription"]>;
type UatSubscriptionProduct = UatSubscription["products"][number];
function dateValue(value: Date | null): number | null {
return value?.getTime() ?? null;
}
function subscriptionProductSafetyProjection(product: UatSubscriptionProduct): unknown {
return {
id: product.id,
customEntitlementPlanId: product.customEntitlementPlanId,
cancelledAt: dateValue(product.cancelledAt),
endsAt: dateValue(product.endsAt),
billingProviderSubscriptionId: product.billingProviderSubscriptionId,
lagoSubscriptionId: product.lagoSubscriptionId,
planCode: product.planCode,
seatQuantity: product.seatQuantity,
quantity: product.quantity,
fromCheckoutSessionId: product.fromCheckoutSessionId,
currentPeriodStart: dateValue(product.currentPeriodStart),
currentPeriodEnd: dateValue(product.currentPeriodEnd),
priceIds: product.prices.map((price) => price.id).sort(),
acquisitionId: product.acquisition?.id ?? null,
subscriptionProduct: product.subscriptionProduct,
};
}
export function starterSubscriptionSafetyMatches(actual: UatSubscription, expected: UatSubscription): boolean {
return isDeepStrictEqual(
{
id: actual.id,
planCode: actual.planCode,
seatQuantity: actual.seatQuantity,
status: actual.status,
billingProviderCustomerId: actual.billingProviderCustomerId,
lagoCustomerId: actual.lagoCustomerId,
mollieCustomerId: actual.mollieCustomerId,
lastInvoiceExternalId: actual.lastInvoiceExternalId,
lastPaymentExternalId: actual.lastPaymentExternalId,
trialStartsAt: dateValue(actual.trialStartsAt),
trialEndsAt: dateValue(actual.trialEndsAt),
pastDueSince: dateValue(actual.pastDueSince),
frozenAt: dateValue(actual.frozenAt),
cancelledAt: dateValue(actual.cancelledAt),
dunningAttemptCount: actual.dunningAttemptCount,
lastDunningSentAt: dateValue(actual.lastDunningSentAt),
products: actual.products
.map(subscriptionProductSafetyProjection)
.sort((left, right) => String((left as { id: string }).id).localeCompare(String((right as { id: string }).id))),
},
{
id: expected.id,
planCode: expected.planCode,
seatQuantity: expected.seatQuantity,
status: expected.status,
billingProviderCustomerId: expected.billingProviderCustomerId,
lagoCustomerId: expected.lagoCustomerId,
mollieCustomerId: expected.mollieCustomerId,
lastInvoiceExternalId: expected.lastInvoiceExternalId,
lastPaymentExternalId: expected.lastPaymentExternalId,
trialStartsAt: dateValue(expected.trialStartsAt),
trialEndsAt: dateValue(expected.trialEndsAt),
pastDueSince: dateValue(expected.pastDueSince),
frozenAt: dateValue(expected.frozenAt),
cancelledAt: dateValue(expected.cancelledAt),
dunningAttemptCount: expected.dunningAttemptCount,
lastDunningSentAt: dateValue(expected.lastDunningSentAt),
products: expected.products
.map(subscriptionProductSafetyProjection)
.sort((left, right) => String((left as { id: string }).id).localeCompare(String((right as { id: string }).id))),
}
);
}
function hasSafeAttachedStarterProductEnvelope(
product: NonNullable<NonNullable<UatTenantSnapshot["tenant"]>["subscription"]>["products"][number],
expectedSeatQuantity: number
): boolean {
return (
product.subscriptionProduct.code === "starter" &&
product.subscriptionProduct.kind === "base_plan" &&
product.subscriptionProduct.active &&
(product.customEntitlementPlanId === null || product.customEntitlementPlanId === "starter") &&
product.cancelledAt === null &&
product.endsAt === null &&
!hasProviderIdentity(product.billingProviderSubscriptionId) &&
!hasProviderIdentity(product.lagoSubscriptionId) &&
product.quantity === expectedSeatQuantity &&
product.fromCheckoutSessionId === null &&
product.currentPeriodStart === null &&
product.currentPeriodEnd === null &&
product.prices.length === 0 &&
product.acquisition === null
);
}
function isCanonicalAttachedStarterProduct(
product: NonNullable<NonNullable<UatTenantSnapshot["tenant"]>["subscription"]>["products"][number],
expectedSeatQuantity: number
): boolean {
return (
hasSafeAttachedStarterProductEnvelope(product, expectedSeatQuantity) && product.planCode === "starter" && product.seatQuantity === expectedSeatQuantity
);
}
function isLegacyNormalizableAttachedStarterProduct(product: UatSubscriptionProduct, expectedSeatQuantity: number): boolean {
return (
hasSafeAttachedStarterProductEnvelope(product, expectedSeatQuantity) &&
product.customEntitlementPlanId === "starter" &&
product.planCode === null &&
product.seatQuantity === null
);
}
function starterBaseProductsAreSafe(subscription: NonNullable<NonNullable<UatTenantSnapshot["tenant"]>["subscription"]>): boolean {
return subscription.products.length <= 1 && subscription.products.every((product) => isCanonicalAttachedStarterProduct(product, subscription.seatQuantity));
}
function hasNoStarterBillingHistory(subscription: UatSubscription): boolean {
return (
!hasProviderIdentity(subscription.billingProviderCustomerId) &&
!hasProviderIdentity(subscription.lagoCustomerId) &&
!hasProviderIdentity(subscription.mollieCustomerId) &&
!hasProviderIdentity(subscription.lastInvoiceExternalId) &&
!hasProviderIdentity(subscription.lastPaymentExternalId) &&
subscription.pastDueSince === null &&
subscription.frozenAt === null &&
subscription.cancelledAt === null &&
subscription.dunningAttemptCount === 0 &&
subscription.lastDunningSentAt === null
);
}
function isCanonicalActiveStarterSubscription(subscription: UatSubscription): boolean {
return (
subscription.planCode === "starter" &&
subscription.status.toLowerCase() === "active" &&
subscription.trialStartsAt === null &&
subscription.trialEndsAt === null &&
hasNoStarterBillingHistory(subscription)
);
}
function hasLegacyNormalizableStarterAttachment(subscription: UatSubscription): boolean {
return (
isCanonicalActiveStarterSubscription(subscription) &&
subscription.products.length === 1 &&
isLegacyNormalizableAttachedStarterProduct(subscription.products[0]!, subscription.seatQuantity)
);
}
function isSafeUnpaidStarterSubscription(subscription: NonNullable<NonNullable<UatTenantSnapshot["tenant"]>["subscription"]>): boolean {
return (
(subscription.planCode === null || subscription.planCode === "starter") &&
subscription.status.toLowerCase() === "trial" &&
hasNoStarterBillingHistory(subscription) &&
starterBaseProductsAreSafe(subscription)
);
}
function enterpriseCatalogIsCanonical(snapshot: CustomerPortalCommercialFixtureSnapshot): boolean {
const product = snapshot.enterpriseProducts[0];
const expected = customerPortalCommercialProducts.enterpriseContract;
return (
snapshot.enterpriseProducts.length === 1 &&
product?.code === expected.code &&
product.kind === expected.source &&
product.active &&
!product.public &&
product.prices.length === 0 &&
product.features.length === expected.featureKeys.length &&
expected.featureKeys.every((featureKey) => product.features.some((feature) => feature.name === featureKey))
);
}
function expectedEnterpriseRequestHash(tenantId: string, productId: string): string {
return createHash("sha256")
.update(
JSON.stringify({
tenantId,
productId,
priceId: null,
productKind: "contract_override",
scopeKey: UAT_ENTERPRISE_SCOPE_KEY,
quantity: 1,
amountCents: null,
currency: null,
sourceReference: UAT_ENTERPRISE_CONTRACT_REFERENCE,
})
)
.digest("hex");
}
function isCanonicalEnterpriseBaseProduct(product: UatSubscriptionProduct): boolean {
return (
product.id === UAT_ENTERPRISE_BASE_PRODUCT_ID &&
product.subscriptionProduct.code === "pro" &&
product.subscriptionProduct.kind === "base_plan" &&
product.subscriptionProduct.active &&
product.customEntitlementPlanId === "pro" &&
product.planCode === "pro" &&
product.seatQuantity === 1 &&
product.quantity === 1 &&
product.cancelledAt === null &&
product.endsAt === null &&
!hasProviderIdentity(product.billingProviderSubscriptionId) &&
!hasProviderIdentity(product.lagoSubscriptionId) &&
product.fromCheckoutSessionId === null &&
product.currentPeriodStart === null &&
product.currentPeriodEnd === null &&
product.prices.length === 0 &&
product.acquisition === null
);
}
function isCanonicalEnterpriseContractAttachment(product: UatSubscriptionProduct, acquisitionId: string, productId: string): boolean {
return (
product.id === acquisitionId &&
product.subscriptionProduct.id === productId &&
product.subscriptionProduct.code === customerPortalCommercialProducts.enterpriseContract.code &&
product.subscriptionProduct.kind === "contract_override" &&
product.subscriptionProduct.active &&
product.customEntitlementPlanId === null &&
product.planCode === null &&
product.seatQuantity === null &&
product.quantity === 1 &&
product.cancelledAt === null &&
product.endsAt === null &&
!hasProviderIdentity(product.billingProviderSubscriptionId) &&
!hasProviderIdentity(product.lagoSubscriptionId) &&
product.fromCheckoutSessionId === null &&
product.currentPeriodStart instanceof Date &&
product.currentPeriodEnd === null &&
product.prices.length === 0 &&
product.acquisition?.id === acquisitionId
);
}
function isProviderlessEnterpriseSubscription(subscription: UatSubscription): boolean {
return (
subscription.id === UAT_ENTERPRISE_SUBSCRIPTION_ID &&
subscription.planCode === "pro" &&
subscription.seatQuantity === 1 &&
subscription.status === "active" &&
!hasProviderIdentity(subscription.billingProviderCustomerId) &&
!hasProviderIdentity(subscription.lagoCustomerId) &&
!hasProviderIdentity(subscription.mollieCustomerId) &&
!hasProviderIdentity(subscription.lastInvoiceExternalId) &&
!hasProviderIdentity(subscription.lastPaymentExternalId) &&
subscription.trialStartsAt === null &&
subscription.trialEndsAt === null &&
subscription.pastDueSince === null &&
subscription.frozenAt === null &&
subscription.cancelledAt === null &&
subscription.dunningAttemptCount === 0 &&
subscription.lastDunningSentAt === null
);
}
function enterprisePortalConfigurationIsCanonical(snapshot: NonNullable<UatTenantSnapshot["portal"]>): boolean {
const configuration = snapshot.configuration;
return Boolean(
snapshot.id === UAT_ENTERPRISE_PORTAL_ID &&
snapshot.subdomain === CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG &&
snapshot.title === "Demo Enterprise CRM Kundenportal" &&
snapshot.isPublished &&
!snapshot.authRequireEmailVerification &&
!snapshot.authRequireOrganization &&
snapshot.authRequireName &&
isUatPortal(snapshot.metadata) &&
configuration &&
configuration.id === UAT_ENTERPRISE_CONFIGURATION_ID &&
configuration.enabledProjectTypes.length === 0 &&
configuration.uploadMaxFiles === 10 &&
configuration.uploadMaxFileSizeBytes === 52_428_800 &&
configuration.statusEmailsEnabled &&
configuration.welcomeMessage === "Willkommen im HiveGrid Test-Kundenportal." &&
configuration.supportEmail === "support@saas-ctrl.com" &&
configuration.imprintUrl === `${UAT_LEGAL_ORIGIN}/impressum` &&
configuration.privacyUrl === `${UAT_LEGAL_ORIGIN}/datenschutz` &&
configuration.isDemoData
);
}
function canonicalEnterpriseAcquisition(snapshot: UatTenantSnapshot, requireAudit = true) {
const acquisition = snapshot.enterpriseAcquisitions[0];
const subscription = snapshot.tenant?.subscription;
if (!acquisition || !subscription) return null;
const expectedContractScope = portalEnterpriseClaimScopeKey(acquisition.id);
const claimsCanonical =
snapshot.enterpriseContractClaims.length <= 1 && snapshot.enterpriseContractClaims.every((claim) => claim.billingScopeKey === expectedContractScope);
const contractAttachment = subscription.products.find((product) => product.id === acquisition.id);
const exact =
snapshot.enterpriseAcquisitions.length === 1 &&
acquisition.subscriptionProduct.code === customerPortalCommercialProducts.enterpriseContract.code &&
acquisition.subscriptionProduct.kind === "contract_override" &&
acquisition.subscriptionProduct.active &&
!acquisition.subscriptionProduct.public &&
acquisition.subscriptionPriceId === null &&
acquisition.productKind === "contract_override" &&
acquisition.scopeKey === UAT_ENTERPRISE_SCOPE_KEY &&
acquisition.requestHash === expectedEnterpriseRequestHash(snapshot.expectedId, acquisition.subscriptionProductId) &&
acquisition.status === "active" &&
acquisition.version === 3 &&
acquisition.quantity === 1 &&
acquisition.amountCents === null &&
acquisition.currency === null &&
acquisition.checkoutSessionId === null &&
acquisition.tenantSubscriptionProductId === acquisition.id &&
!hasProviderIdentity(acquisition.provider) &&
!hasProviderIdentity(acquisition.providerPaymentId) &&
!hasProviderIdentity(acquisition.invoiceExternalId) &&
!hasProviderIdentity(acquisition.lagoSubscriptionId) &&
!hasProviderIdentity(acquisition.checkoutUrl) &&
acquisition.sourceReference === UAT_ENTERPRISE_CONTRACT_REFERENCE &&
acquisition.providerStartedAt === null &&
acquisition.activatedAt instanceof Date &&
acquisition.failedAt === null &&
acquisition.cancelledAt === null &&
acquisition.expiredAt === null &&
acquisition.refundedAt === null &&
snapshot.checkoutSessions.length === 0 &&
claimsCanonical &&
Boolean(contractAttachment && isCanonicalEnterpriseContractAttachment(contractAttachment, acquisition.id, acquisition.subscriptionProductId)) &&
(!requireAudit || snapshot.enterpriseGrantAudited);
return exact ? acquisition : null;
}
function assessTenant(snapshot: UatTenantSnapshot, reconcileIssues: string[], blockingIssues: string[]): void {
const label = snapshot.kind;
if (!snapshot.tenant) {
if (snapshot.kind === "enterprise") {
reconcileIssues.push("enterprise: create the dedicated deterministic UAT tenant and contract graph");
} else {
blockingIssues.push(`${label}: explicitly bound tenant is not visible under RLS`);
}
return;
}
if (snapshot.tenant.id !== snapshot.expectedId || snapshot.tenant.slug !== snapshot.expectedSlug) {
blockingIssues.push(`${label}: tenant id and slug do not match the explicit binding`);
}
if (!snapshot.tenant.active) blockingIssues.push(`${label}: tenant is inactive`);
const subscription = snapshot.tenant.subscription;
if (!subscription) {
blockingIssues.push(`${label}: base subscription is missing`);
} else if (snapshot.kind === "starter") {
const activeStarter = isCanonicalActiveStarterSubscription(subscription);
const legacyNormalizableAttachment = hasLegacyNormalizableStarterAttachment(subscription);
if (!activeStarter) {
if (isSafeUnpaidStarterSubscription(subscription)) reconcileIssues.push("starter: activate the empty starter base subscription for checkout");
else blockingIssues.push("starter: existing base subscription has provider, billing, product, or lifecycle state that the UAT fixture may not replace");
}
if (legacyNormalizableAttachment) {
reconcileIssues.push("starter: normalize the providerless legacy starter base-plan attachment");
} else if (!starterBaseProductsAreSafe(subscription)) {
blockingIssues.push("starter: existing subscription product state is not the single providerless canonical starter base plan");
} else if (subscription.products.length === 0) {
reconcileIssues.push("starter: providerless canonical starter base-plan entitlement row missing");
}
if (snapshot.monthlyAcquisitions.length > 0 || subscription.products.some((product) => product.subscriptionProduct.code === "customer_portal_monthly")) {
blockingIssues.push("starter: portal monthly add-on already has ledger or subscription state; the UAT fixture must not pre-purchase it");
}
} else if (
snapshot.kind === "pro" &&
(subscription.planCode !== "business" ||
subscription.status.toLowerCase() !== "active" ||
subscription.frozenAt !== null ||
subscription.cancelledAt !== null)
) {
blockingIssues.push("pro: expected the existing active business fixture that proves the included base-plan path");
} else if (snapshot.kind === "enterprise") {
const baseProducts = subscription.products.filter((product) => product.subscriptionProduct.kind === "base_plan");
const structuralContract = canonicalEnterpriseAcquisition(snapshot, false);
const allowedProductIds = new Set([UAT_ENTERPRISE_BASE_PRODUCT_ID, ...(structuralContract ? [structuralContract.id] : [])]);
if (!isProviderlessEnterpriseSubscription(subscription)) {
blockingIssues.push("enterprise: the dedicated UAT tenant does not have the exact providerless active pro base subscription");
}
if (baseProducts.length !== 1 || !isCanonicalEnterpriseBaseProduct(baseProducts[0]!)) {
blockingIssues.push("enterprise: the exact providerless pro base-plan attachment is missing or drifted");
}
if (subscription.products.some((product) => !allowedProductIds.has(product.id))) {
blockingIssues.push("enterprise: unexpected subscription products would make the contract proof ambiguous");
}
if (snapshot.enterpriseAcquisitions.length === 0) {
reconcileIssues.push("enterprise: canonical contract_override acquisition missing");
} else if (!structuralContract) {
blockingIssues.push("enterprise: contract_override ledger, CAS state, attachment, audit, or providerless contract has drifted");
} else if (!snapshot.enterpriseGrantAudited) {
reconcileIssues.push("enterprise: contract_override grant audit evidence missing");
}
if (
snapshot.commercialEligibility.portalSource !== "contract_override" ||
!snapshot.commercialEligibility.portalAllowed ||
!snapshot.commercialEligibility.domainSetupActive ||
!snapshot.commercialEligibility.domainSetupIncludedByContract ||
snapshot.commercialEligibility.enterpriseContractAcquisitionId !== structuralContract?.id ||
snapshot.commercialEligibility.domainSetupAcquisitionId !== null
) {
if (snapshot.enterpriseAcquisitions.length === 0) {
reconcileIssues.push("enterprise: canonical commercial eligibility still lacks the contract override");
} else {
blockingIssues.push("enterprise: canonical eligibility does not resolve portalSource=contract_override and one included domain");
}
}
}
if (snapshot.kind !== "enterprise" && snapshot.enterpriseAcquisitions.length > 0) {
blockingIssues.push(`${label}: Enterprise contract_override would mask the commercial path under test`);
}
const expectedRoleId = roleId(snapshot.kind);
const role = snapshot.roleCandidates.find((candidate) => candidate.id === expectedRoleId);
if (snapshot.roleCandidates.length === 0) reconcileIssues.push(`${label}: dedicated portal-admin role missing`);
else if (snapshot.roleCandidates.length !== 1 || !role || role.tenantId !== snapshot.expectedId || role.name !== UAT_ROLE_NAME) {
blockingIssues.push(`${label}: deterministic portal-admin role id or name collides with existing data`);
} else {
const permissionNames = role.permissions.map((entry) => entry.permission.name);
const extraPermissions = permissionNames.filter((name) => !UAT_REQUIRED_PERMISSIONS.includes(name as (typeof UAT_REQUIRED_PERMISSIONS)[number]));
if (extraPermissions.length > 0) blockingIssues.push(`${label}: dedicated UAT role has unexpected permissions`);
for (const permission of UAT_REQUIRED_PERMISSIONS) {
if (!permissionNames.includes(permission)) reconcileIssues.push(`${label}: dedicated UAT role is missing ${permission}`);
}
if (role.description !== UAT_ROLE_DESCRIPTION || role.type !== "app" || role.assignToNewUsers || role.isDefault || role.order !== 990) {
reconcileIssues.push(`${label}: dedicated UAT role metadata differs from the guarded contract`);
}
}
const expectedMembershipId = membershipId(snapshot.kind);
const membership = snapshot.membershipCandidates.find((candidate) => candidate.id === expectedMembershipId);
if (snapshot.membershipCandidates.length === 0) reconcileIssues.push(`${label}: dedicated admin membership missing`);
else if (
snapshot.membershipCandidates.length !== 1 ||
!membership ||
membership.tenantId !== snapshot.expectedId ||
membership.userId !== UAT_ADMIN_USER_ID
) {
blockingIssues.push(`${label}: deterministic membership id or user binding collides with existing data`);
} else if (membership.type !== 1 || membership.joined !== 1 || membership.status !== 2) {
reconcileIssues.push(`${label}: dedicated admin membership is inactive or has the wrong tenant-admin contract`);
}
const expectedAssignmentId = assignmentId(snapshot.kind);
const assignment = snapshot.assignmentCandidates.find((candidate) => candidate.id === expectedAssignmentId);
if (snapshot.assignmentCandidates.length === 0) reconcileIssues.push(`${label}: dedicated portal-admin role assignment missing`);
else if (
snapshot.assignmentCandidates.length !== 1 ||
!assignment ||
assignment.tenantId !== snapshot.expectedId ||
assignment.userId !== UAT_ADMIN_USER_ID ||
assignment.roleId !== expectedRoleId
) {
blockingIssues.push(`${label}: dedicated UAT user has an unexpected role assignment or id collision`);
}
if (snapshot.kind === "starter") {
if (!snapshot.portal) reconcileIssues.push("starter: UAT-owned published portal missing");
else if (!isUatPortal(snapshot.portal.metadata)) blockingIssues.push("starter: existing portal is not owned by the VA-P26c commercial fixture");
else {
if (
snapshot.portal.subdomain !== CUSTOMER_PORTAL_UAT_STARTER_TENANT_SLUG ||
!snapshot.portal.isPublished ||
snapshot.portal.authRequireEmailVerification
) {
reconcileIssues.push("starter: UAT portal publication or login contract differs");
}
if (!snapshot.portal.configuration) reconcileIssues.push("starter: UAT portal configuration missing");
else if (!snapshot.portal.configuration.isDemoData) blockingIssues.push("starter: existing portal configuration is not UAT-owned demo data");
else if (
snapshot.portal.configuration.enabledProjectTypes.length !== 0 ||
snapshot.portal.configuration.uploadMaxFiles < 2 ||
snapshot.portal.configuration.uploadMaxFileSizeBytes < 1_024 ||
!snapshot.portal.configuration.imprintUrl ||
!snapshot.portal.configuration.privacyUrl
) {
reconcileIssues.push("starter: UAT portal configuration differs from the checkout-ready contract");
}
}
} else if (snapshot.kind === "pro" && (!snapshot.portal || !isDemoProPortal(snapshot.portal.metadata) || !snapshot.portal.isPublished)) {
blockingIssues.push("pro: the separate VA-P26 portal fixture must be applied and published before commercial UAT");
} else if (snapshot.kind === "enterprise" && (!snapshot.portal || !enterprisePortalConfigurationIsCanonical(snapshot.portal))) {
blockingIssues.push("enterprise: the deterministic UAT-owned Portal or configuration is missing or drifted");
}
}
export function assessCustomerPortalCommercialFixture(snapshot: CustomerPortalCommercialFixtureSnapshot): CustomerPortalCommercialFixtureAssessment {
const reconcileIssues: string[] = [];
const blockingIssues: string[] = [];
const user = snapshot.userCandidates.find((candidate) => candidate.id === UAT_ADMIN_USER_ID);
if (snapshot.userCandidates.length === 0) reconcileIssues.push("dedicated saas-ctrl.com tenant-admin identity missing");
else if (
snapshot.userCandidates.length !== 1 ||
!user ||
user.email !== CUSTOMER_PORTAL_UAT_ADMIN_EMAIL ||
user.hasPlatformAdmin ||
user.pendingDeletion ||
user.pseudonymized
) {
blockingIssues.push("dedicated tenant-admin id/email collides with existing or platform-admin data");
} else if (
!user.active ||
!user.passwordMatches ||
user.firstName !== "Portal" ||
user.lastName !== "UAT Admin" ||
user.defaultTenantId !== snapshot.tenants.find((tenant) => tenant.kind === "starter")?.expectedId
) {
reconcileIssues.push("dedicated tenant-admin identity differs from the login contract");
}
for (const permissionName of UAT_REQUIRED_PERMISSIONS) {
if (snapshot.permissions.filter((permission) => permission.name === permissionName).length !== 1) {
blockingIssues.push(`global permission catalog is missing or ambiguous for ${permissionName}`);
}
}
if (
snapshot.starterBaseProducts.length !== 1 ||
snapshot.starterBaseProducts[0]?.code !== "starter" ||
snapshot.starterBaseProducts[0].kind !== "base_plan" ||
!snapshot.starterBaseProducts[0].active
) {
blockingIssues.push("canonical active starter base-plan catalog product is missing or ambiguous");
}
if (
snapshot.proBaseProducts.length !== 1 ||
snapshot.proBaseProducts[0]?.code !== "pro" ||
snapshot.proBaseProducts[0].kind !== "base_plan" ||
!snapshot.proBaseProducts[0].active
) {
blockingIssues.push("canonical active pro base-plan catalog product is missing or ambiguous");
}
if (
snapshot.enterpriseTenantCandidates.length > 1 ||
(snapshot.enterpriseTenantCandidates.length === 1 &&
(snapshot.enterpriseTenantCandidates[0]?.id !== snapshot.tenants.find((tenant) => tenant.kind === "enterprise")?.expectedId ||
snapshot.enterpriseTenantCandidates[0]?.slug !== CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG ||
snapshot.enterpriseTenantCandidates[0]?.name !== UAT_ENTERPRISE_TENANT_NAME))
) {
blockingIssues.push("enterprise: deterministic tenant id or slug collides with non-UAT staging data");
}
if (!enterpriseCatalogIsCanonical(snapshot)) {
blockingIssues.push("enterprise contract_override product is missing or differs from the canonical non-public catalog contract");
}
for (const tenant of snapshot.tenants) assessTenant(tenant, reconcileIssues, blockingIssues);
const starter = snapshot.tenants.find((tenant) => tenant.kind === "starter");
const business = snapshot.tenants.find((tenant) => tenant.kind === "pro");
const enterprise = snapshot.tenants.find((tenant) => tenant.kind === "enterprise");
const enterpriseAcquisition = enterprise ? canonicalEnterpriseAcquisition(enterprise) : null;
const starterSubscription = starter?.tenant?.subscription;
const starterMonthlyCheckoutReady = Boolean(
starterSubscription &&
isCanonicalActiveStarterSubscription(starterSubscription) &&
starterSubscription.products.length === 1 &&
starterSubscription.products.every((product) => isCanonicalAttachedStarterProduct(product, starterSubscription.seatQuantity)) &&
starter?.monthlyAcquisitions.length === 0 &&
!starterSubscription.products.some((product) => product.subscriptionProduct.code === "customer_portal_monthly")
);
return {
action: blockingIssues.length > 0 ? "blocked" : reconcileIssues.length > 0 ? "reconcile" : "noop",
reconcileIssues,
blockingIssues,
liveProof: {
adminEmail: CUSTOMER_PORTAL_UAT_ADMIN_EMAIL,
starterTenantSlug: CUSTOMER_PORTAL_UAT_STARTER_TENANT_SLUG,
proTenantSlug: CUSTOMER_PORTAL_UAT_TENANT_SLUG,
enterpriseTenantSlug: CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG,
starterMonthlyCheckoutReady,
businessBasePlanReady:
business?.commercialEligibility.portalSource === "base_plan" && business.commercialEligibility.enterpriseContractAcquisitionId === null,
enterpriseCatalogReady: enterpriseCatalogIsCanonical(snapshot),
enterpriseContractGrantReady: Boolean(enterpriseAcquisition),
enterprisePortalSource: enterprise?.commercialEligibility.portalSource ?? "missing",
enterpriseDomainSetupIncludedByContract: enterprise?.commercialEligibility.domainSetupIncludedByContract ?? false,
enterpriseCheckoutRows: enterprise?.checkoutSessions.length ?? 0,
enterpriseAcquisitionId: enterpriseAcquisition?.id ?? null,
},
};
}
async function readTenantSnapshot(
db: DbClient,
input: { readonly kind: CommercialTenantKind; readonly expectedId: string; readonly expectedSlug: string }
): Promise<UatTenantSnapshot> {
const expectedRoleId = roleId(input.kind);
const expectedMembershipId = membershipId(input.kind);
const expectedAssignmentId = assignmentId(input.kind);
const tenant = await db.tenant.findFirst({
where: { id: input.expectedId, slug: input.expectedSlug },
select: {
id: true,
slug: true,
name: true,
active: true,
subscription: {
select: {
id: true,
planCode: true,
seatQuantity: true,
status: true,
billingProviderCustomerId: true,
lagoCustomerId: true,
mollieCustomerId: true,
lastInvoiceExternalId: true,
lastPaymentExternalId: true,
trialStartsAt: true,
trialEndsAt: true,
pastDueSince: true,
frozenAt: true,
cancelledAt: true,
dunningAttemptCount: true,
lastDunningSentAt: true,
products: {
select: {
id: true,
customEntitlementPlanId: true,
cancelledAt: true,
endsAt: true,
billingProviderSubscriptionId: true,
lagoSubscriptionId: true,
planCode: true,
seatQuantity: true,
quantity: true,
fromCheckoutSessionId: true,
currentPeriodStart: true,
currentPeriodEnd: true,
prices: { select: { id: true } },
acquisition: { select: { id: true } },
subscriptionProduct: { select: { id: true, code: true, kind: true, active: true } },
},
},
},
},
},
});
// Keep the operator inspection sequential. Every model operation owns a
// short RLS transaction, and overlapping those transactions on the tiny
// two-connection operator pool can otherwise make the Pg adapter reuse a
// connection while it is still completing the previous query.
const portal = await db.portal.findUnique({
where: { tenantId: input.expectedId },
select: {
id: true,
subdomain: true,
title: true,
isPublished: true,
authRequireEmailVerification: true,
authRequireOrganization: true,
authRequireName: true,
metadata: true,
configuration: {
select: {
id: true,
enabledProjectTypes: true,
uploadMaxFiles: true,
uploadMaxFileSizeBytes: true,
statusEmailsEnabled: true,
welcomeMessage: true,
supportEmail: true,
imprintUrl: true,
privacyUrl: true,
isDemoData: true,
},
},
},
});
const roleCandidates = await db.role.findMany({
where: { OR: [{ id: expectedRoleId }, { tenantId: input.expectedId, name: UAT_ROLE_NAME }] },
select: {
id: true,
tenantId: true,
name: true,
description: true,
type: true,
assignToNewUsers: true,
isDefault: true,
order: true,
permissions: { select: { id: true, permission: { select: { id: true, name: true } } } },
},
});
const membershipCandidates = await db.tenantUser.findMany({
where: { OR: [{ id: expectedMembershipId }, { tenantId: input.expectedId, userId: UAT_ADMIN_USER_ID }] },
select: { id: true, tenantId: true, userId: true, type: true, joined: true, status: true },
});
const assignmentCandidates = await db.userRole.findMany({
where: { OR: [{ id: expectedAssignmentId }, { tenantId: input.expectedId, userId: UAT_ADMIN_USER_ID }] },
select: { id: true, tenantId: true, userId: true, roleId: true },
});
const monthlyAcquisitions = await db.tenantProductAcquisition.findMany({
where: { tenantId: input.expectedId, subscriptionProduct: { code: "customer_portal_monthly" } },
select: { id: true, status: true, subscriptionProduct: { select: { code: true } } },
});
const enterpriseAcquisitions = await db.tenantProductAcquisition.findMany({
where: { tenantId: input.expectedId, subscriptionProduct: { code: customerPortalCommercialProducts.enterpriseContract.code } },
select: {
id: true,
subscriptionProductId: true,
subscriptionPriceId: true,
productKind: true,
scopeKey: true,
requestHash: true,
status: true,
version: true,
quantity: true,
amountCents: true,
currency: true,
checkoutSessionId: true,
tenantSubscriptionProductId: true,
provider: true,
providerPaymentId: true,
invoiceExternalId: true,
lagoSubscriptionId: true,
checkoutUrl: true,
sourceReference: true,
providerStartedAt: true,
activatedAt: true,
failedAt: true,
cancelledAt: true,
expiredAt: true,
refundedAt: true,
subscriptionProduct: { select: { id: true, code: true, kind: true, active: true, public: true } },
},
});
const checkoutSessions = await db.checkoutSessionStatus.findMany({
where: { tenantId: input.expectedId },
select: {
id: true,
productKind: true,
subscriptionProductId: true,
provider: true,
providerPaymentId: true,
lagoSubscriptionId: true,
checkoutUrl: true,
},
});
const enterpriseContractClaims = await db.portalDomainHostnameClaim.findMany({
where: { tenantId: input.expectedId, billingScopeKey: { startsWith: "enterprise-contract:" } },
select: { id: true, billingScopeKey: true },
orderBy: [{ createdAt: "asc" }, { id: "asc" }],
});
const eligibilityClaimId = enterpriseContractClaims.length === 1 ? enterpriseContractClaims[0]?.id : undefined;
const commercialEligibility = await getCustomerPortalCommercialEligibility(
{ tenantId: input.expectedId, ...(eligibilityClaimId ? { claimId: eligibilityClaimId } : {}) },
{ withTenant: async (_tenantId, operation) => operation(db as never) }
);
const acquisitionIds = new Set(enterpriseAcquisitions.map((acquisition) => acquisition.id));
const auditEvents =
acquisitionIds.size === 0
? []
: await db.auditEvent.findMany({
where: { tenantId: input.expectedId, action: UAT_ENTERPRISE_AUDIT_ACTION, targetId: { in: [...acquisitionIds] } },
select: { targetId: true },
});
const auditOutboxEvents = await db.outboxEvent.findMany({
where: { tenantId: input.expectedId, eventType: "audit.event.create" },
select: { payload: true },
});
const enterpriseGrantAudited =
auditEvents.some((event) => Boolean(event.targetId && acquisitionIds.has(event.targetId))) ||
auditOutboxEvents.some((event) => {
const payload = event.payload;
if (!payload || typeof payload !== "object" || Array.isArray(payload)) return false;
const record = payload as Record<string, unknown>;
return record.action === UAT_ENTERPRISE_AUDIT_ACTION && typeof record.targetId === "string" && acquisitionIds.has(record.targetId);
});
return {
...input,
tenant,
portal,
roleCandidates,
membershipCandidates,
assignmentCandidates,
monthlyAcquisitions,
enterpriseAcquisitions,
checkoutSessions,
enterpriseContractClaims,
commercialEligibility,
enterpriseGrantAudited,
};
}
export async function readCustomerPortalCommercialFixture(
db: DbClient,
command: CustomerPortalCommercialFixtureCommand
): Promise<CustomerPortalCommercialFixtureSnapshot> {
const rawUsers = await db.user.findMany({
where: { OR: [{ id: UAT_ADMIN_USER_ID }, { email: CUSTOMER_PORTAL_UAT_ADMIN_EMAIL }] },
select: {
id: true,
email: true,
passwordHash: true,
firstName: true,
lastName: true,
defaultTenantId: true,
active: true,
pendingDeletion: true,
pseudonymized: true,
admin: { select: { userId: true } },
},
});
const permissions = await db.permission.findMany({
where: { name: { in: [...UAT_REQUIRED_PERMISSIONS] } },
select: { id: true, name: true },
});
const enterpriseProducts = await db.subscriptionProduct.findMany({
where: { code: customerPortalCommercialProducts.enterpriseContract.code },
select: {
id: true,
code: true,
kind: true,
active: true,
public: true,
prices: { select: { id: true } },
features: { select: { name: true } },
},
});
const starterBaseProducts = await db.subscriptionProduct.findMany({
where: { code: "starter", kind: "base_plan" },
select: { id: true, code: true, kind: true, active: true },
});
const proBaseProducts = await db.subscriptionProduct.findMany({
where: { code: "pro", kind: "base_plan" },
select: { id: true, code: true, kind: true, active: true },
});
const enterpriseTenantCandidates = await db.tenant.findMany({
where: {
OR: [{ id: command.expectedEnterpriseTenantId }, { slug: CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG }],
},
select: { id: true, slug: true, name: true, active: true },
});
const starter = await runWithRlsContext({ tenantId: command.expectedStarterTenantId }, () =>
readTenantSnapshot(db, {
kind: "starter",
expectedId: command.expectedStarterTenantId,
expectedSlug: CUSTOMER_PORTAL_UAT_STARTER_TENANT_SLUG,
})
);
const pro = await runWithRlsContext({ tenantId: command.expectedProTenantId }, () =>
readTenantSnapshot(db, { kind: "pro", expectedId: command.expectedProTenantId, expectedSlug: CUSTOMER_PORTAL_UAT_TENANT_SLUG })
);
const enterprise = await runWithRlsContext({ tenantId: command.expectedEnterpriseTenantId }, () =>
readTenantSnapshot(db, {
kind: "enterprise",
expectedId: command.expectedEnterpriseTenantId,
expectedSlug: CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG,
})
);
const userCandidates = await Promise.all(
rawUsers.map(async ({ passwordHash, admin, ...user }) => ({
...user,
hasPlatformAdmin: Boolean(admin),
passwordMatches: passwordHash ? await verifySupportedPassword(command.password, passwordHash) : false,
}))
);
return {
userCandidates,
permissions,
enterpriseProducts,
starterBaseProducts,
proBaseProducts,
enterpriseTenantCandidates,
tenants: [starter, pro, enterprise],
};
}
async function applyGlobalAdminIdentity(db: DbClient, command: CustomerPortalCommercialFixtureCommand): Promise<void> {
const passwordHash = await hashCurrentPassword(command.password);
await db.$transaction(async (tx) => {
await tx.$queryRaw`
SELECT uat_user."id"
FROM "User" AS uat_user
WHERE uat_user."id" = ${UAT_ADMIN_USER_ID}
OR uat_user."email" = ${CUSTOMER_PORTAL_UAT_ADMIN_EMAIL}
FOR UPDATE
`;
const currentCandidates = await tx.user.findMany({
where: { OR: [{ id: UAT_ADMIN_USER_ID }, { email: CUSTOMER_PORTAL_UAT_ADMIN_EMAIL }] },
select: {
id: true,
email: true,
pendingDeletion: true,
pseudonymized: true,
admin: { select: { userId: true } },
},
});
const current = currentCandidates[0];
if (
currentCandidates.length > 1 ||
(current &&
(current.id !== UAT_ADMIN_USER_ID ||
current.email !== CUSTOMER_PORTAL_UAT_ADMIN_EMAIL ||
current.pendingDeletion ||
current.pseudonymized ||
Boolean(current.admin)))
) {
throw new CustomerPortalUatError("customer-portal UAT: dedicated tenant-admin ownership changed after guarded preflight");
}
const userData = {
email: CUSTOMER_PORTAL_UAT_ADMIN_EMAIL,
passwordHash,
firstName: "Portal",
lastName: "UAT Admin",
defaultTenantId: command.expectedStarterTenantId,
locale: "de",
active: true,
} as const;
if (!current) {
await tx.user.create({
data: {
id: UAT_ADMIN_USER_ID,
...userData,
},
});
} else {
await tx.user.update({
where: { id: UAT_ADMIN_USER_ID },
data: userData,
});
}
await publishAuditEventViaOutbox(tx, {
tenantId: command.expectedStarterTenantId,
actorId: command.operatorUserId,
actorType: "operator",
action: "customer_portal.uat_commercial_admin.provisioned",
targetType: "User",
targetId: UAT_ADMIN_USER_ID,
sourceModule: "customer-portal-uat",
outcome: "success",
dataSensitivity: "internal",
regulatoryScope: ["none"],
metadata: { tenantCount: 3, emailDomain: "saas-ctrl.com" },
});
});
}
async function lockCommercialTenantFixtureRows(db: DbClient, tenant: UatTenantSnapshot): Promise<void> {
const tenantLocks = await db.$queryRaw<Array<{ id: string }>>`
SELECT target_tenant."id"
FROM "Tenant" AS target_tenant
WHERE target_tenant."id" = ${tenant.expectedId}
AND target_tenant."slug" = ${tenant.expectedSlug}
FOR UPDATE
`;
if (tenantLocks.length !== 1) {
throw new CustomerPortalUatError("customer-portal UAT: commercial tenant changed after guarded preflight");
}
await db.$queryRaw`
SELECT uat_user."id"
FROM "User" AS uat_user
WHERE uat_user."id" = ${UAT_ADMIN_USER_ID}
AND uat_user."email" = ${CUSTOMER_PORTAL_UAT_ADMIN_EMAIL}
FOR UPDATE
`;
await db.$queryRaw`
SELECT portal."id"
FROM "Portal" AS portal
WHERE portal."tenantId" = ${tenant.expectedId}
FOR UPDATE
`;
await db.$queryRaw`
SELECT configuration."id"
FROM "PortalConfiguration" AS configuration
WHERE configuration."tenantId" = ${tenant.expectedId}
FOR UPDATE
`;
await db.$queryRaw`
SELECT role."id"
FROM "Role" AS role
WHERE role."id" = ${roleId(tenant.kind)}
OR (role."tenantId" = ${tenant.expectedId} AND role."name" = ${UAT_ROLE_NAME})
FOR UPDATE
`;
await db.$queryRaw`
SELECT role_permission."id"
FROM "RolePermission" AS role_permission
JOIN "Role" AS role ON role."id" = role_permission."roleId"
WHERE role."id" = ${roleId(tenant.kind)}
OR (role."tenantId" = ${tenant.expectedId} AND role."name" = ${UAT_ROLE_NAME})
FOR UPDATE OF role_permission
`;
await db.$queryRaw`
SELECT membership."id"
FROM "TenantUser" AS membership
WHERE membership."id" = ${membershipId(tenant.kind)}
OR (membership."tenantId" = ${tenant.expectedId} AND membership."userId" = ${UAT_ADMIN_USER_ID})
FOR UPDATE
`;
await db.$queryRaw`
SELECT assignment."id"
FROM "UserRole" AS assignment
WHERE assignment."id" = ${assignmentId(tenant.kind)}
OR (assignment."tenantId" = ${tenant.expectedId} AND assignment."userId" = ${UAT_ADMIN_USER_ID})
FOR UPDATE
`;
await db.$queryRaw`
SELECT acquisition."id"
FROM "TenantProductAcquisition" AS acquisition
JOIN "SubscriptionProduct" AS product ON product."id" = acquisition."subscriptionProductId"
WHERE acquisition."tenantId" = ${tenant.expectedId}
AND product."code" = 'customer_portal_monthly'
FOR UPDATE OF acquisition, product
`;
}
async function applyTenantFixture(
db: DbClient,
command: CustomerPortalCommercialFixtureCommand,
preflightTenant: UatTenantSnapshot,
starterBaseProductId: string
): Promise<void> {
const expectedRoleId = roleId(preflightTenant.kind);
await db.$transaction(async (tx) => {
const transactionDb = tx as unknown as DbClient;
await lockCommercialTenantFixtureRows(transactionDb, preflightTenant);
const tenant = await readTenantSnapshot(transactionDb, {
kind: preflightTenant.kind,
expectedId: preflightTenant.expectedId,
expectedSlug: preflightTenant.expectedSlug,
});
const blockingIssues: string[] = [];
assessTenant(tenant, [], blockingIssues);
const currentUser = await tx.user.findUnique({
where: { id: UAT_ADMIN_USER_ID },
select: { id: true, email: true, pendingDeletion: true, pseudonymized: true, admin: { select: { userId: true } } },
});
if (
blockingIssues.length > 0 ||
!currentUser ||
currentUser.email !== CUSTOMER_PORTAL_UAT_ADMIN_EMAIL ||
currentUser.pendingDeletion ||
currentUser.pseudonymized ||
Boolean(currentUser.admin)
) {
throw new CustomerPortalUatError("customer-portal UAT: commercial fixture ownership changed after guarded preflight");
}
const permissionByName = new Map(
(
await tx.permission.findMany({
where: { name: { in: [...UAT_REQUIRED_PERMISSIONS] } },
select: { id: true, name: true },
})
).map((permission) => [permission.name, permission.id])
);
if (permissionByName.size !== UAT_REQUIRED_PERMISSIONS.length) {
throw new CustomerPortalUatError("customer-portal UAT: commercial permission catalog changed after guarded preflight");
}
if (tenant.kind === "starter") {
const subscription = tenant.tenant?.subscription;
if (!subscription) throw new CustomerPortalUatError("customer-portal UAT: starter base subscription disappeared before apply");
const subscriptionLocks = await tx.$queryRaw<Array<{ id: string }>>`
SELECT subscription."id"
FROM "TenantSubscription" AS subscription
WHERE subscription."id" = ${subscription.id}
AND subscription."tenantId" = ${tenant.expectedId}
FOR UPDATE
`;
const productLocks = await tx.$queryRaw<Array<{ id: string }>>`
SELECT attached."id"
FROM "TenantSubscriptionProduct" AS attached
JOIN "SubscriptionProduct" AS catalog
ON catalog."id" = attached."subscriptionProductId"
WHERE attached."tenantSubscriptionId" = ${subscription.id}
ORDER BY attached."id"
FOR UPDATE OF attached, catalog
`;
const starterCatalogLocks = await tx.$queryRaw<Array<{ id: string; code: string | null; kind: string; active: boolean }>>`
SELECT catalog."id", catalog."code", catalog."kind"::text AS "kind", catalog."active"
FROM "SubscriptionProduct" AS catalog
WHERE catalog."id" = ${starterBaseProductId}
FOR UPDATE
`;
if (
subscriptionLocks.length !== 1 ||
productLocks.length !== subscription.products.length ||
starterCatalogLocks.length !== 1 ||
starterCatalogLocks[0]?.code !== "starter" ||
starterCatalogLocks[0].kind !== "base_plan" ||
!starterCatalogLocks[0].active
) {
throw new CustomerPortalUatError("customer-portal UAT: starter subscription or catalog changed after guarded preflight");
}
const currentSubscriptionRow = await tx.tenantSubscription.findUnique({
where: { id: subscription.id },
select: {
id: true,
planCode: true,
seatQuantity: true,
status: true,
billingProviderCustomerId: true,
lagoCustomerId: true,
mollieCustomerId: true,
lastInvoiceExternalId: true,
lastPaymentExternalId: true,
trialStartsAt: true,
trialEndsAt: true,
pastDueSince: true,
frozenAt: true,
cancelledAt: true,
dunningAttemptCount: true,
lastDunningSentAt: true,
products: {
select: {
id: true,
customEntitlementPlanId: true,
cancelledAt: true,
endsAt: true,
billingProviderSubscriptionId: true,
lagoSubscriptionId: true,
planCode: true,
seatQuantity: true,
quantity: true,
fromCheckoutSessionId: true,
currentPeriodStart: true,
currentPeriodEnd: true,
prices: { select: { id: true } },
acquisition: { select: { id: true } },
subscriptionProduct: { select: { id: true, code: true, kind: true, active: true } },
},
},
},
});
const currentSubscription = currentSubscriptionRow
? {
...currentSubscriptionRow,
products: currentSubscriptionRow.products.map((product) => ({
...product,
subscriptionProduct: { ...product.subscriptionProduct, kind: String(product.subscriptionProduct.kind) },
})),
}
: null;
if (!currentSubscription || !starterSubscriptionSafetyMatches(currentSubscription, subscription)) {
throw new CustomerPortalUatError("customer-portal UAT: starter subscription safety state changed after guarded preflight");
}
const legacyNormalizableProduct =
subscription.products.length === 1 &&
isLegacyNormalizableAttachedStarterProduct(subscription.products[0]!, subscription.seatQuantity) &&
subscription.products[0]!.subscriptionProduct.id === starterBaseProductId
? subscription.products[0]!
: null;
if (hasLegacyNormalizableStarterAttachment(subscription) && !legacyNormalizableProduct) {
throw new CustomerPortalUatError("customer-portal UAT: legacy starter attachment catalog changed after guarded preflight");
}
const subscriptionUpdate = await tx.tenantSubscription.updateMany({
where: {
id: subscription.id,
tenantId: tenant.expectedId,
planCode: subscription.planCode,
seatQuantity: subscription.seatQuantity,
status: subscription.status,
billingProviderCustomerId: subscription.billingProviderCustomerId,
lagoCustomerId: subscription.lagoCustomerId,
mollieCustomerId: subscription.mollieCustomerId,
lastInvoiceExternalId: subscription.lastInvoiceExternalId,
lastPaymentExternalId: subscription.lastPaymentExternalId,
trialStartsAt: subscription.trialStartsAt,
trialEndsAt: subscription.trialEndsAt,
pastDueSince: subscription.pastDueSince,
frozenAt: subscription.frozenAt,
cancelledAt: subscription.cancelledAt,
dunningAttemptCount: subscription.dunningAttemptCount,
lastDunningSentAt: subscription.lastDunningSentAt,
products: { none: { subscriptionProduct: { code: "customer_portal_monthly" } } },
},
data: {
planCode: "starter",
status: "active",
trialStartsAt: null,
trialEndsAt: null,
pastDueSince: null,
frozenAt: null,
cancelledAt: null,
},
});
if (subscriptionUpdate.count !== 1) {
throw new CustomerPortalUatError("customer-portal UAT: starter subscription changed after guarded preflight");
}
if (subscription.products.length === 0) {
await tx.tenantSubscriptionProduct.create({
data: {
id: "customer-portal-uat-starter-base-product",
tenantSubscriptionId: subscription.id,
subscriptionProductId: starterBaseProductId,
billingProviderSubscriptionId: null,
lagoSubscriptionId: null,
planCode: "starter",
customEntitlementPlanId: "starter",
seatQuantity: subscription.seatQuantity,
quantity: subscription.seatQuantity,
fromCheckoutSessionId: null,
},
});
} else if (legacyNormalizableProduct) {
const productUpdate = await tx.tenantSubscriptionProduct.updateMany({
where: {
id: legacyNormalizableProduct.id,
tenantSubscriptionId: subscription.id,
subscriptionProductId: starterBaseProductId,
customEntitlementPlanId: "starter",
cancelledAt: null,
endsAt: null,
billingProviderSubscriptionId: null,
lagoSubscriptionId: null,
planCode: null,
seatQuantity: null,
quantity: subscription.seatQuantity,
fromCheckoutSessionId: null,
currentPeriodStart: null,
currentPeriodEnd: null,
prices: { none: {} },
acquisition: null,
subscriptionProduct: { id: starterBaseProductId, code: "starter", kind: "base_plan", active: true },
},
data: { planCode: "starter", seatQuantity: subscription.seatQuantity },
});
if (productUpdate.count !== 1) {
throw new CustomerPortalUatError("customer-portal UAT: legacy starter attachment changed after guarded preflight");
}
}
const portal = tenant.portal
? await tx.portal.update({
where: { id: tenant.portal.id },
data: {
createdByUserId: UAT_ADMIN_USER_ID,
subdomain: CUSTOMER_PORTAL_UAT_STARTER_TENANT_SLUG,
title: "Demo Starter CRM Kundenportal",
isPublished: true,
authRequireEmailVerification: false,
authRequireOrganization: false,
authRequireName: true,
},
select: { id: true },
})
: await tx.portal.create({
data: {
id: "customer-portal-uat-demo-starter-crm",
tenantId: tenant.expectedId,
createdByUserId: UAT_ADMIN_USER_ID,
subdomain: CUSTOMER_PORTAL_UAT_STARTER_TENANT_SLUG,
title: "Demo Starter CRM Kundenportal",
isPublished: true,
authRequireEmailVerification: false,
authRequireOrganization: false,
authRequireName: true,
metadata: { uatFixture: UAT_PORTAL_MARKER },
},
select: { id: true },
});
const portalConfigurationData = {
lifecycleMode: "customer" as const,
enabledProjectTypes: [] as string[],
uploadMaxFiles: 10,
uploadMaxFileSizeBytes: 52_428_800,
statusEmailsEnabled: true,
welcomeMessage: "Willkommen im HiveGrid Test-Kundenportal.",
supportEmail: "support@saas-ctrl.com",
imprintUrl: `${UAT_LEGAL_ORIGIN}/impressum`,
privacyUrl: `${UAT_LEGAL_ORIGIN}/datenschutz`,
isDemoData: true,
};
if (tenant.portal?.configuration) {
await tx.portalConfiguration.update({
where: { id: tenant.portal.configuration.id },
data: portalConfigurationData,
});
} else {
await tx.portalConfiguration.create({
data: {
id: "customer-portal-uat-starter-configuration",
tenantId: tenant.expectedId,
portalId: portal.id,
...portalConfigurationData,
},
});
}
}
const roleData = {
description: UAT_ROLE_DESCRIPTION,
type: "app",
assignToNewUsers: false,
isDefault: false,
order: 990,
} as const;
if (tenant.roleCandidates.length === 0) {
await tx.role.create({
data: {
id: expectedRoleId,
tenantId: tenant.expectedId,
name: UAT_ROLE_NAME,
...roleData,
},
});
} else {
await tx.role.update({
where: { id: expectedRoleId },
data: roleData,
});
}
for (const permissionName of UAT_REQUIRED_PERMISSIONS) {
const permissionId = permissionByName.get(permissionName);
if (!permissionId) throw new CustomerPortalUatError(`customer-portal UAT: required permission ${permissionName} disappeared before apply`);
const existing = await tx.rolePermission.findFirst({ where: { roleId: expectedRoleId, permissionId }, select: { id: true } });
if (!existing) {
await tx.rolePermission.create({
data: { id: `${expectedRoleId}-${permissionName.replaceAll(".", "-")}`, roleId: expectedRoleId, permissionId },
});
}
}
const tenantUserData = { type: 1, joined: 1, status: 2, seatType: "office" as const };
if (tenant.membershipCandidates.length === 0) {
await tx.tenantUser.create({
data: {
id: membershipId(tenant.kind),
tenantId: tenant.expectedId,
userId: UAT_ADMIN_USER_ID,
...tenantUserData,
},
});
} else {
await tx.tenantUser.update({
where: { id: membershipId(tenant.kind) },
data: tenantUserData,
});
}
if (tenant.assignmentCandidates.length === 0) {
await tx.userRole.create({
data: {
id: assignmentId(tenant.kind),
tenantId: tenant.expectedId,
userId: UAT_ADMIN_USER_ID,
roleId: expectedRoleId,
},
});
}
await publishAuditEventViaOutbox(tx, {
tenantId: tenant.expectedId,
actorId: command.operatorUserId,
actorType: "operator",
action: "customer_portal.uat_commercial_fixture.provisioned",
targetType: "Tenant",
targetId: tenant.expectedId,
sourceModule: "customer-portal-uat",
outcome: "success",
dataSensitivity: "internal",
regulatoryScope: ["none"],
metadata: {
tenantSlug: tenant.expectedSlug,
packagePath: tenant.kind === "starter" ? "recurring_add_on" : "base_plan",
portalMonthlyAcquisitionCreated: false,
enterpriseContractAcquisitionCreated: false,
},
});
});
}
export async function applyEnterpriseTenantFixture(
db: DbClient,
command: CustomerPortalCommercialFixtureCommand,
enterpriseBaseProductId: string,
enterpriseContractProductId: string
): Promise<void> {
const tenantId = command.expectedEnterpriseTenantId;
const expectedRoleId = roleId("enterprise");
await db.$transaction(async (tx) => {
const transactionDb = tx as unknown as DbClient;
await tx.$queryRaw`
SELECT pg_catalog.pg_advisory_xact_lock(
pg_catalog.hashtextextended(${`customer-portal-uat:${CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG}`}, 26026)
)::text AS "lock"
`;
await tx.$queryRaw`
SELECT target_tenant."id"
FROM "Tenant" AS target_tenant
WHERE target_tenant."id" = ${tenantId}
OR target_tenant."slug" = ${CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG}
FOR UPDATE
`;
const userLocks = await tx.$queryRaw<Array<{ id: string }>>`
SELECT uat_user."id"
FROM "User" AS uat_user
WHERE uat_user."id" = ${UAT_ADMIN_USER_ID}
AND uat_user."email" = ${CUSTOMER_PORTAL_UAT_ADMIN_EMAIL}
FOR UPDATE
`;
await tx.$queryRaw`
SELECT subscription."id"
FROM "TenantSubscription" AS subscription
WHERE subscription."tenantId" = ${tenantId}
FOR UPDATE
`;
await tx.$queryRaw`
SELECT attached."id"
FROM "TenantSubscriptionProduct" AS attached
JOIN "TenantSubscription" AS subscription ON subscription."id" = attached."tenantSubscriptionId"
WHERE subscription."tenantId" = ${tenantId}
ORDER BY attached."id"
FOR UPDATE OF attached
`;
const catalogLocks = await tx.$queryRaw<Array<{ id: string; code: string | null; kind: string; active: boolean; public: boolean }>>`
SELECT product."id", product."code", product."kind"::text AS "kind", product."active", product."public"
FROM "SubscriptionProduct" AS product
WHERE product."id" IN (${enterpriseBaseProductId}, ${enterpriseContractProductId})
ORDER BY product."id"
FOR UPDATE
`;
await tx.$queryRaw`
SELECT acquisition."id"
FROM "TenantProductAcquisition" AS acquisition
WHERE acquisition."tenantId" = ${tenantId}
ORDER BY acquisition."id"
FOR UPDATE
`;
await tx.$queryRaw`
SELECT checkout."id"
FROM "CheckoutSessionStatus" AS checkout
WHERE checkout."tenantId" = ${tenantId}
ORDER BY checkout."id"
FOR UPDATE
`;
await tx.$queryRaw`
SELECT portal."id"
FROM "Portal" AS portal
WHERE portal."tenantId" = ${tenantId}
FOR UPDATE
`;
await tx.$queryRaw`
SELECT configuration."id"
FROM "PortalConfiguration" AS configuration
WHERE configuration."tenantId" = ${tenantId}
FOR UPDATE
`;
await tx.$queryRaw`
SELECT role."id"
FROM "Role" AS role
WHERE role."id" = ${expectedRoleId}
OR (role."tenantId" = ${tenantId} AND role."name" = ${UAT_ROLE_NAME})
FOR UPDATE
`;
await tx.$queryRaw`
SELECT role_permission."id"
FROM "RolePermission" AS role_permission
JOIN "Role" AS role ON role."id" = role_permission."roleId"
WHERE role."id" = ${expectedRoleId}
FOR UPDATE OF role_permission
`;
await tx.$queryRaw`
SELECT membership."id"
FROM "TenantUser" AS membership
WHERE membership."id" = ${membershipId("enterprise")}
OR (membership."tenantId" = ${tenantId} AND membership."userId" = ${UAT_ADMIN_USER_ID})
FOR UPDATE
`;
await tx.$queryRaw`
SELECT assignment."id"
FROM "UserRole" AS assignment
WHERE assignment."id" = ${assignmentId("enterprise")}
OR (assignment."tenantId" = ${tenantId} AND assignment."userId" = ${UAT_ADMIN_USER_ID})
FOR UPDATE
`;
const baseCatalog = catalogLocks.find((product) => product.id === enterpriseBaseProductId);
const contractCatalog = catalogLocks.find((product) => product.id === enterpriseContractProductId);
if (
userLocks.length !== 1 ||
catalogLocks.length !== 2 ||
baseCatalog?.code !== "pro" ||
baseCatalog.kind !== "base_plan" ||
!baseCatalog.active ||
contractCatalog?.code !== customerPortalCommercialProducts.enterpriseContract.code ||
contractCatalog.kind !== "contract_override" ||
!contractCatalog.active ||
contractCatalog.public
) {
throw new CustomerPortalUatError("customer-portal UAT: Enterprise identity or catalog changed after guarded preflight");
}
const current = await readTenantSnapshot(transactionDb, {
kind: "enterprise",
expectedId: tenantId,
expectedSlug: CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG,
});
const currentBlockingIssues: string[] = [];
assessTenant(current, [], currentBlockingIssues);
if (currentBlockingIssues.length > 0) {
throw new CustomerPortalUatError("customer-portal UAT: Enterprise fixture ownership or commercial state changed after guarded preflight");
}
if (!current.tenant) {
await tx.tenant.create({
data: {
id: tenantId,
slug: CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG,
name: UAT_ENTERPRISE_TENANT_NAME,
icon: "",
active: true,
},
});
await tx.tenantSubscription.create({
data: {
id: UAT_ENTERPRISE_SUBSCRIPTION_ID,
tenantId,
planCode: "pro",
seatQuantity: 1,
status: "active",
billingProviderCustomerId: null,
lagoCustomerId: null,
mollieCustomerId: null,
},
});
await tx.tenantSubscriptionProduct.create({
data: {
id: UAT_ENTERPRISE_BASE_PRODUCT_ID,
tenantSubscriptionId: UAT_ENTERPRISE_SUBSCRIPTION_ID,
subscriptionProductId: enterpriseBaseProductId,
customEntitlementPlanId: "pro",
planCode: "pro",
seatQuantity: 1,
quantity: 1,
billingProviderSubscriptionId: null,
lagoSubscriptionId: null,
fromCheckoutSessionId: null,
},
});
await tx.portal.create({
data: {
id: UAT_ENTERPRISE_PORTAL_ID,
tenantId,
createdByUserId: UAT_ADMIN_USER_ID,
subdomain: CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG,
title: "Demo Enterprise CRM Kundenportal",
isPublished: true,
authRequireEmailVerification: false,
authRequireOrganization: false,
authRequireName: true,
metadata: { uatFixture: UAT_PORTAL_MARKER },
},
});
await tx.portalConfiguration.create({
data: {
id: UAT_ENTERPRISE_CONFIGURATION_ID,
tenantId,
portalId: UAT_ENTERPRISE_PORTAL_ID,
lifecycleMode: "customer",
enabledProjectTypes: [],
uploadMaxFiles: 10,
uploadMaxFileSizeBytes: 52_428_800,
statusEmailsEnabled: true,
welcomeMessage: "Willkommen im HiveGrid Test-Kundenportal.",
supportEmail: "support@saas-ctrl.com",
imprintUrl: `${UAT_LEGAL_ORIGIN}/impressum`,
privacyUrl: `${UAT_LEGAL_ORIGIN}/datenschutz`,
isDemoData: true,
},
});
}
const permissionByName = new Map(
(
await tx.permission.findMany({
where: { name: { in: [...UAT_REQUIRED_PERMISSIONS] } },
select: { id: true, name: true },
})
).map((permission) => [permission.name, permission.id])
);
if (permissionByName.size !== UAT_REQUIRED_PERMISSIONS.length) {
throw new CustomerPortalUatError("customer-portal UAT: commercial permission catalog changed before Enterprise apply");
}
const roleData = {
description: UAT_ROLE_DESCRIPTION,
type: "app",
assignToNewUsers: false,
isDefault: false,
order: 990,
} as const;
if (current.roleCandidates.length === 0) {
await tx.role.create({ data: { id: expectedRoleId, tenantId, name: UAT_ROLE_NAME, ...roleData } });
} else {
await tx.role.update({ where: { id: expectedRoleId }, data: roleData });
}
for (const permissionName of UAT_REQUIRED_PERMISSIONS) {
const permissionId = permissionByName.get(permissionName);
if (!permissionId) throw new CustomerPortalUatError(`customer-portal UAT: required permission ${permissionName} disappeared before Enterprise apply`);
const existing = await tx.rolePermission.findFirst({ where: { roleId: expectedRoleId, permissionId }, select: { id: true } });
if (!existing) {
await tx.rolePermission.create({
data: { id: `${expectedRoleId}-${permissionName.replaceAll(".", "-")}`, roleId: expectedRoleId, permissionId },
});
}
}
const tenantUserData = { type: 1, joined: 1, status: 2, seatType: "office" as const };
if (current.membershipCandidates.length === 0) {
await tx.tenantUser.create({
data: { id: membershipId("enterprise"), tenantId, userId: UAT_ADMIN_USER_ID, ...tenantUserData },
});
} else {
await tx.tenantUser.update({ where: { id: membershipId("enterprise") }, data: tenantUserData });
}
if (current.assignmentCandidates.length === 0) {
await tx.userRole.create({
data: { id: assignmentId("enterprise"), tenantId, userId: UAT_ADMIN_USER_ID, roleId: expectedRoleId },
});
}
const grant = await grantEnterpriseCustomerPortalContract(
{
tenantId,
actorUserId: command.operatorUserId,
productId: enterpriseContractProductId,
contractReference: UAT_ENTERPRISE_CONTRACT_REFERENCE,
quantity: 1,
},
{
withTenant: async (_tenantId, operation) => operation(transactionDb as never),
grantContract: (input) =>
grantContractProductAcquisition(input, {
client: transactionDb as unknown as ProductAcquisitionClient,
activationTransaction: async (operation) => operation(transactionDb as never),
}),
}
);
if (
grant.status !== "active" ||
grant.productKind !== "contract_override" ||
grant.scopeKey !== UAT_ENTERPRISE_SCOPE_KEY ||
grant.checkoutUrl !== null ||
grant.providerPaymentId !== null
) {
throw new CustomerPortalUatError("customer-portal UAT: Enterprise contract grant did not converge without checkout");
}
if (!current.enterpriseGrantAudited || !grant.replayed) {
await publishAuditEventViaOutbox(tx, {
tenantId,
actorId: command.operatorUserId,
actorType: "operator",
action: UAT_ENTERPRISE_AUDIT_ACTION,
targetType: "TenantProductAcquisition",
targetId: grant.id,
sourceModule: "billing",
outcome: "success",
dataSensitivity: "internal",
regulatoryScope: ["none"],
metadata: {
tenantSlug: CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG,
subscriptionProductCode: customerPortalCommercialProducts.enterpriseContract.code,
productKind: "contract_override",
scopeKey: UAT_ENTERPRISE_SCOPE_KEY,
quantity: 1,
checkoutCreated: false,
replayed: grant.replayed,
},
});
}
await publishAuditEventViaOutbox(tx, {
tenantId,
actorId: command.operatorUserId,
actorType: "operator",
action: "customer_portal.uat_commercial_fixture.provisioned",
targetType: "Tenant",
targetId: tenantId,
sourceModule: "customer-portal-uat",
outcome: "success",
dataSensitivity: "internal",
regulatoryScope: ["none"],
metadata: {
tenantSlug: CUSTOMER_PORTAL_UAT_ENTERPRISE_TENANT_SLUG,
packagePath: "contract_override",
basePlan: "pro",
portalMonthlyAcquisitionCreated: false,
enterpriseContractAcquisitionId: grant.id,
checkoutCreated: false,
},
});
});
}
export async function applyCustomerPortalCommercialFixture(
db: DbClient,
command: CustomerPortalCommercialFixtureCommand,
snapshot: CustomerPortalCommercialFixtureSnapshot
): Promise<void> {
const assessment = assessCustomerPortalCommercialFixture(snapshot);
if (assessment.action === "blocked") {
throw new CustomerPortalUatError("customer-portal UAT: commercial fixture apply is blocked by mismatched or non-UAT staging state");
}
if (assessment.action === "noop") return;
await runWithRlsContext({ tenantId: command.expectedStarterTenantId }, () => applyGlobalAdminIdentity(db, command));
const starterBaseProductId = snapshot.starterBaseProducts[0]?.id;
const enterpriseBaseProductId = snapshot.proBaseProducts[0]?.id;
const enterpriseContractProductId = snapshot.enterpriseProducts[0]?.id;
if (!starterBaseProductId || !enterpriseBaseProductId || !enterpriseContractProductId) {
throw new CustomerPortalUatError("customer-portal UAT: canonical commercial catalog disappeared before apply");
}
for (const tenant of snapshot.tenants.filter((candidate) => candidate.kind !== "enterprise")) {
await runWithRlsContext({ tenantId: tenant.expectedId }, () => applyTenantFixture(db, command, tenant, starterBaseProductId));
}
const enterprise = snapshot.tenants.find((tenant) => tenant.kind === "enterprise");
if (!enterprise) throw new CustomerPortalUatError("customer-portal UAT: Enterprise snapshot disappeared before apply");
const enterpriseReconcileIssues: string[] = [];
const enterpriseBlockingIssues: string[] = [];
assessTenant(enterprise, enterpriseReconcileIssues, enterpriseBlockingIssues);
if (enterpriseBlockingIssues.length > 0) {
throw new CustomerPortalUatError("customer-portal UAT: Enterprise snapshot became unsafe before apply");
}
if (enterpriseReconcileIssues.length > 0) {
await runWithRlsContext({ tenantId: command.expectedEnterpriseTenantId }, () =>
applyEnterpriseTenantFixture(db, command, enterpriseBaseProductId, enterpriseContractProductId)
);
}
}
export const customerPortalCommercialFixtureIds = Object.freeze({
userId: UAT_ADMIN_USER_ID,
starterRoleId: roleId("starter"),
proRoleId: roleId("pro"),
enterpriseRoleId: roleId("enterprise"),
starterMembershipId: membershipId("starter"),
proMembershipId: membershipId("pro"),
enterpriseMembershipId: membershipId("enterprise"),
starterAssignmentId: assignmentId("starter"),
proAssignmentId: assignmentId("pro"),
enterpriseAssignmentId: assignmentId("enterprise"),
enterpriseSubscriptionId: UAT_ENTERPRISE_SUBSCRIPTION_ID,
enterpriseBaseProductId: UAT_ENTERPRISE_BASE_PRODUCT_ID,
enterprisePortalId: UAT_ENTERPRISE_PORTAL_ID,
enterpriseConfigurationId: UAT_ENTERPRISE_CONFIGURATION_ID,
});