Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/db/src/entitlements-seed.server.ts
T

517 lines
19 KiB
TypeScript

import {
assertKnownFeatureKey,
billingCadences,
customerPortalCommercialProducts,
emailMarketingCommercialProducts,
entitlementLimitTypes,
getBillingCatalogVariantForSelection,
getCommercialProductFeatureLimit,
getFeatureGate,
standardEntitlementPlans,
type BillingCatalogPlanVariant,
type CommercialProductDefinition,
type EntitlementLimitType,
type EntitlementPlanStub,
type FeatureKey,
} from "@hivegrid/entitlements";
import { getDbClient } from "./client.server.js";
import type { SubscriptionFeature, SubscriptionPrice, SubscriptionProduct } from "./prisma-browser.js";
import type {
SubscriptionFeatureCreateInput,
SubscriptionPriceCreateInput,
SubscriptionPriceUpdateInput,
SubscriptionProductCreateInput,
SubscriptionProductUpdateInput,
} from "./subscriptions.server.js";
const SEEDED_BILLING_PROVIDER_ID_PREFIX = "hivegrid_entitlement_plan";
const SEEDED_PRICE_PROVIDER_ID_PREFIX = "hivegrid_entitlement_price";
const REDACTED = "[redacted]";
const PRICE_TYPE_RECURRING = 1;
const BILLING_PERIOD_MONTHLY = 3;
const BILLING_PERIOD_YEARLY = 4;
const BILLING_PERIOD_ONE_TIME = 0;
const SEEDED_COMMERCIAL_PRODUCT_PREFIX = "hivegrid_commercial_product";
const SEEDED_COMMERCIAL_PRICE_PREFIX = "hivegrid_commercial_price";
export type EntitlementsSeedPhase = "start" | "plan-seeded" | "success" | "failure";
export type EntitlementsSeedDiagnosticEvent = {
phase: EntitlementsSeedPhase;
planCount: number;
featureCount: number;
createdProducts: number;
updatedProducts: number;
createdPrices: number;
updatedPrices: number;
deletedFeatures: number;
createdFeatures: number;
planId?: string;
error?: {
name: string;
message: string;
};
};
export type EntitlementsSeedDiagnostics = (event: EntitlementsSeedDiagnosticEvent) => void | Promise<void>;
export type EntitlementsSeedResult = {
planCount: number;
featureCount: number;
createdProducts: number;
updatedProducts: number;
createdPrices: number;
updatedPrices: number;
deletedFeatures: number;
createdFeatures: number;
};
export type EntitlementsSeedSubscriptionProductClient = {
findFirst(args: { where: { OR: [{ billingProviderId: string }, { title: string }] } }): Promise<Pick<SubscriptionProduct, "id"> | null>;
create(args: { data: SubscriptionProductCreateInput }): Promise<Pick<SubscriptionProduct, "id">>;
update(args: { where: { id: string }; data: SubscriptionProductUpdateInput }): Promise<Pick<SubscriptionProduct, "id">>;
};
export type EntitlementsSeedSubscriptionFeatureClient = {
deleteMany(args: { where: { subscriptionProductId: string } }): Promise<{ count: number }>;
create(args: { data: SubscriptionFeatureCreateInput & { subscriptionProductId: string } }): Promise<SubscriptionFeature>;
};
export type EntitlementsSeedSubscriptionPriceClient = {
findFirst(args: { where: { subscriptionProductId: string; currency: string; billingPeriod: number } }): Promise<Pick<SubscriptionPrice, "id"> | null>;
create(args: { data: SubscriptionPriceCreateInput }): Promise<SubscriptionPrice>;
update(args: { where: { id: string }; data: SubscriptionPriceUpdateInput }): Promise<SubscriptionPrice>;
};
export type EntitlementsSeedClient = {
subscriptionProduct: EntitlementsSeedSubscriptionProductClient;
subscriptionFeature: EntitlementsSeedSubscriptionFeatureClient;
subscriptionPrice: EntitlementsSeedSubscriptionPriceClient;
};
export type SeedStandardEntitlementsOptions = {
client?: EntitlementsSeedClient;
plans?: readonly EntitlementPlanStub[];
includeCustomerPortalCommercialProducts?: boolean;
includeEmailMarketingCommercialProducts?: boolean;
diagnostics?: EntitlementsSeedDiagnostics;
};
function getInitialResult(plans: readonly EntitlementPlanStub[], commercialProducts: readonly CommercialProductDefinition[]): EntitlementsSeedResult {
return {
planCount: plans.length + commercialProducts.length,
featureCount:
plans.reduce((total, plan) => total + plan.features.length, 0) + commercialProducts.reduce((total, product) => total + product.featureKeys.length, 0),
createdProducts: 0,
updatedProducts: 0,
createdPrices: 0,
updatedPrices: 0,
deletedFeatures: 0,
createdFeatures: 0,
};
}
function diagnosticFromResult(phase: EntitlementsSeedPhase, result: EntitlementsSeedResult, planId?: string): EntitlementsSeedDiagnosticEvent {
return {
phase,
planCount: result.planCount,
featureCount: result.featureCount,
createdProducts: result.createdProducts,
updatedProducts: result.updatedProducts,
createdPrices: result.createdPrices,
updatedPrices: result.updatedPrices,
deletedFeatures: result.deletedFeatures,
createdFeatures: result.createdFeatures,
...(planId ? { planId } : {}),
};
}
async function emitDiagnostic(diagnostics: EntitlementsSeedDiagnostics | undefined, event: EntitlementsSeedDiagnosticEvent): Promise<void> {
await diagnostics?.(event);
}
export function getEntitlementPlanBillingProviderId(plan: Pick<EntitlementPlanStub, "id">): string {
return `${SEEDED_BILLING_PROVIDER_ID_PREFIX}_${plan.id}`;
}
function mapPlanToProductCreateInput(plan: EntitlementPlanStub): SubscriptionProductCreateInput {
return {
billingProviderId: getEntitlementPlanBillingProviderId(plan),
code: plan.id,
lagoPlanCode: plan.id,
kind: "base_plan",
order: plan.metadata.sortOrder,
title: plan.metadata.publicName,
model: 0,
public: plan.metadata.isPublic,
active: true,
description: plan.metadata.description,
badge: null,
groupTitle: null,
groupDescription: null,
billingAddressCollection: "auto",
hasQuantity: false,
canBuyAgain: false,
};
}
function mapPlanToProductUpdateInput(plan: EntitlementPlanStub): SubscriptionProductUpdateInput {
const product = mapPlanToProductCreateInput(plan);
return {
billingProviderId: product.billingProviderId,
code: product.code,
lagoPlanCode: product.lagoPlanCode,
kind: product.kind,
order: product.order,
title: product.title,
model: product.model,
public: product.public,
description: product.description,
badge: product.badge,
groupTitle: product.groupTitle,
groupDescription: product.groupDescription,
billingAddressCollection: product.billingAddressCollection,
hasQuantity: product.hasQuantity,
canBuyAgain: product.canBuyAgain,
};
}
function commercialProductBillingProviderId(product: CommercialProductDefinition): string {
return `${SEEDED_COMMERCIAL_PRODUCT_PREFIX}_${product.code}`;
}
function commercialPriceBillingProviderId(product: CommercialProductDefinition): string {
return `${SEEDED_COMMERCIAL_PRICE_PREFIX}_${product.code}`;
}
function commercialAmountDecimal(amountCents: number): string {
if (!Number.isSafeInteger(amountCents) || amountCents <= 0) throw new RangeError("Commercial product amount must be a positive cent integer.");
return (amountCents / 100).toFixed(2);
}
function mapCommercialProductCreateInput(product: CommercialProductDefinition): SubscriptionProductCreateInput {
return {
billingProviderId: commercialProductBillingProviderId(product),
code: product.code,
lagoPlanCode: product.source === "recurring_add_on" ? product.code : null,
kind: product.source,
order: product.catalogOrder,
title: product.title,
model: 0,
public: product.public,
active: true,
description: product.description,
badge: null,
groupTitle: product.groupTitle,
groupDescription: null,
billingAddressCollection: "auto",
hasQuantity: false,
canBuyAgain: product.source === "one_time_setup",
};
}
function mapCommercialProductUpdateInput(product: CommercialProductDefinition): SubscriptionProductUpdateInput {
return mapCommercialProductCreateInput(product);
}
async function seedCommercialProduct(
client: EntitlementsSeedClient,
productDefinition: CommercialProductDefinition
): Promise<Omit<EntitlementsSeedResult, "planCount" | "featureCount">> {
const productData = mapCommercialProductCreateInput(productDefinition);
const existingProduct = await client.subscriptionProduct.findFirst({
where: { OR: [{ billingProviderId: productData.billingProviderId }, { title: productData.title }] },
});
const product = existingProduct
? await client.subscriptionProduct.update({ where: { id: existingProduct.id }, data: mapCommercialProductUpdateInput(productDefinition) })
: await client.subscriptionProduct.create({ data: productData });
const deletedFeatures = await client.subscriptionFeature.deleteMany({ where: { subscriptionProductId: product.id } });
for (const [index, featureKey] of productDefinition.featureKeys.entries()) {
assertKnownFeatureKey(featureKey);
const registryItem = getFeatureGate(featureKey);
if (!registryItem) throw new RangeError(`Unknown feature key: ${featureKey}`);
const featureLimit = getCommercialProductFeatureLimit(productDefinition, featureKey);
await client.subscriptionFeature.create({
data: {
subscriptionProductId: product.id,
order: index + 1,
title: registryItem.title,
name: featureKey,
type: featureLimit.limitType,
value: featureLimit.limit ?? featureLimit.limitType,
href: null,
badge: registryItem.title,
accumulate: featureLimit.limitType === entitlementLimitTypes.monthly,
},
});
}
let createdPrices = 0;
let updatedPrices = 0;
if (productDefinition.amountCents !== null && productDefinition.currency !== null) {
const billingPeriod = productDefinition.source === "recurring_add_on" ? BILLING_PERIOD_MONTHLY : BILLING_PERIOD_ONE_TIME;
const billingProviderId = commercialPriceBillingProviderId(productDefinition);
const priceData: SubscriptionPriceCreateInput = {
subscriptionProductId: product.id,
billingProviderId,
lagoPlanCode: productDefinition.source === "recurring_add_on" ? productDefinition.code : null,
lagoFeeCode: productDefinition.code,
molliePriceReference: billingProviderId,
billingCadence: "monthly",
contractMonths: 1,
requiredPaymentMethod: "any",
type: productDefinition.source === "recurring_add_on" ? PRICE_TYPE_RECURRING : 0,
billingPeriod,
price: commercialAmountDecimal(productDefinition.amountCents),
currency: productDefinition.currency.toLowerCase(),
trialDays: 0,
active: true,
};
const existingPrice = await client.subscriptionPrice.findFirst({
where: { subscriptionProductId: product.id, currency: priceData.currency, billingPeriod },
});
if (existingPrice) {
await client.subscriptionPrice.update({
where: { id: existingPrice.id },
data: {
billingProviderId: priceData.billingProviderId,
lagoPlanCode: priceData.lagoPlanCode,
lagoFeeCode: priceData.lagoFeeCode,
molliePriceReference: priceData.molliePriceReference,
billingCadence: priceData.billingCadence,
contractMonths: priceData.contractMonths,
requiredPaymentMethod: priceData.requiredPaymentMethod,
type: priceData.type,
price: priceData.price,
trialDays: priceData.trialDays,
active: priceData.active,
},
});
updatedPrices = 1;
} else {
await client.subscriptionPrice.create({ data: priceData });
createdPrices = 1;
}
}
return {
createdProducts: existingProduct ? 0 : 1,
updatedProducts: existingProduct ? 1 : 0,
createdPrices,
updatedPrices,
deletedFeatures: deletedFeatures.count,
createdFeatures: productDefinition.featureKeys.length,
};
}
function getPriceBillingProviderId(plan: Pick<EntitlementPlanStub, "id">, billingPeriod: number): string {
return `${SEEDED_PRICE_PROVIDER_ID_PREFIX}_${plan.id}_${billingPeriod === BILLING_PERIOD_YEARLY ? "yearly" : "monthly"}`;
}
function getLagoFeeCode(variant: BillingCatalogPlanVariant): string {
return `${variant.code}_base`;
}
function mapPlanPriceToInput(
plan: EntitlementPlanStub,
subscriptionProductId: string,
billingPeriod: number,
variant: BillingCatalogPlanVariant
): SubscriptionPriceCreateInput {
const billingProviderId = getPriceBillingProviderId(plan, billingPeriod);
return {
subscriptionProductId,
billingProviderId,
lagoPlanCode: variant.code,
lagoFeeCode: getLagoFeeCode(variant),
molliePriceReference: billingProviderId,
billingCadence: variant.cadence,
contractMonths: variant.contractMonths,
requiredPaymentMethod: variant.requiredPaymentMethod,
type: PRICE_TYPE_RECURRING,
billingPeriod,
price: (variant.baseAmountCents / 100).toFixed(2),
currency: "eur",
trialDays: 0,
active: true,
};
}
async function seedPlanPrice(
client: EntitlementsSeedClient,
plan: EntitlementPlanStub,
productId: string,
billingPeriod: number,
variant: BillingCatalogPlanVariant
) {
const priceData = mapPlanPriceToInput(plan, productId, billingPeriod, variant);
const existingPrice = await client.subscriptionPrice.findFirst({
where: {
subscriptionProductId: productId,
currency: priceData.currency,
billingPeriod: priceData.billingPeriod,
},
});
if (existingPrice) {
await client.subscriptionPrice.update({
where: { id: existingPrice.id },
data: {
billingProviderId: priceData.billingProviderId,
lagoPlanCode: priceData.lagoPlanCode,
lagoFeeCode: priceData.lagoFeeCode,
molliePriceReference: priceData.molliePriceReference,
billingCadence: priceData.billingCadence,
contractMonths: priceData.contractMonths,
requiredPaymentMethod: priceData.requiredPaymentMethod,
type: priceData.type,
price: priceData.price,
trialDays: priceData.trialDays,
active: priceData.active,
},
});
return { createdPrices: 0, updatedPrices: 1 };
}
await client.subscriptionPrice.create({ data: priceData });
return { createdPrices: 1, updatedPrices: 0 };
}
function getFeatureValue(limitType: EntitlementLimitType, limit: number | null): number {
return limit ?? limitType;
}
function mapPlanFeatureToCreateInput(feature: EntitlementPlanStub["features"][number]): SubscriptionFeatureCreateInput {
assertKnownFeatureKey(feature.featureKey);
const registryItem = getFeatureGate(feature.featureKey as FeatureKey);
if (!registryItem) {
throw new RangeError(`Unknown feature key: ${feature.featureKey}`);
}
return {
order: feature.order,
title: feature.label,
name: feature.featureKey,
type: feature.limitType,
value: getFeatureValue(feature.limitType, feature.limit),
href: null,
badge: registryItem.title,
accumulate: feature.limitType === 2,
};
}
function redactMessage(value: string): string {
return value
.replace(/\b(?:prod|price|sub|cus|tenant|user|acct|sk|pk|rk|cs|plan)_[A-Za-z0-9_-]+\b/g, REDACTED)
.replace(/postgres(?:ql)?:\/\/\S+/gi, REDACTED)
.replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g, REDACTED);
}
export function redactSeedError(error: unknown): { name: string; message: string } {
if (error instanceof Error) {
return {
name: error.name || "Error",
message: redactMessage(error.message),
};
}
return {
name: "Error",
message: redactMessage(String(error)),
};
}
async function seedOnePlan(client: EntitlementsSeedClient, plan: EntitlementPlanStub): Promise<Omit<EntitlementsSeedResult, "planCount" | "featureCount">> {
const productData = mapPlanToProductCreateInput(plan);
const existingProduct = await client.subscriptionProduct.findFirst({
where: { OR: [{ billingProviderId: productData.billingProviderId }, { title: productData.title }] },
});
const product = existingProduct
? await client.subscriptionProduct.update({
where: { id: existingProduct.id },
data: mapPlanToProductUpdateInput(plan),
})
: await client.subscriptionProduct.create({ data: productData });
const deletedFeatures = await client.subscriptionFeature.deleteMany({ where: { subscriptionProductId: product.id } });
let createdPrices = 0;
let updatedPrices = 0;
const monthlyVariant = getBillingCatalogVariantForSelection(plan.id, billingCadences.monthly);
const annualSepaVariant = getBillingCatalogVariantForSelection(plan.id, billingCadences.annualSepa);
if (monthlyVariant && annualSepaVariant) {
const monthly = await seedPlanPrice(client, plan, product.id, BILLING_PERIOD_MONTHLY, monthlyVariant);
const yearly = await seedPlanPrice(client, plan, product.id, BILLING_PERIOD_YEARLY, annualSepaVariant);
createdPrices += monthly.createdPrices + yearly.createdPrices;
updatedPrices += monthly.updatedPrices + yearly.updatedPrices;
}
for (const feature of plan.features) {
await client.subscriptionFeature.create({
data: {
subscriptionProductId: product.id,
...mapPlanFeatureToCreateInput(feature),
},
});
}
return {
createdProducts: existingProduct ? 0 : 1,
updatedProducts: existingProduct ? 1 : 0,
createdPrices,
updatedPrices,
deletedFeatures: deletedFeatures.count,
createdFeatures: plan.features.length,
};
}
export async function seedStandardEntitlements({
client = getDbClient(),
plans = standardEntitlementPlans,
includeCustomerPortalCommercialProducts = false,
includeEmailMarketingCommercialProducts = false,
diagnostics,
}: SeedStandardEntitlementsOptions = {}): Promise<EntitlementsSeedResult> {
const commercialProducts = [
...(includeCustomerPortalCommercialProducts ? Object.values(customerPortalCommercialProducts) : []),
...(includeEmailMarketingCommercialProducts ? emailMarketingCommercialProducts : []),
];
const result = getInitialResult(plans, commercialProducts);
await emitDiagnostic(diagnostics, diagnosticFromResult("start", result));
try {
for (const plan of plans) {
const planResult = await seedOnePlan(client, plan);
result.createdProducts += planResult.createdProducts;
result.updatedProducts += planResult.updatedProducts;
result.createdPrices += planResult.createdPrices;
result.updatedPrices += planResult.updatedPrices;
result.deletedFeatures += planResult.deletedFeatures;
result.createdFeatures += planResult.createdFeatures;
await emitDiagnostic(diagnostics, diagnosticFromResult("plan-seeded", result, plan.id));
}
for (const product of commercialProducts) {
const productResult = await seedCommercialProduct(client, product);
result.createdProducts += productResult.createdProducts;
result.updatedProducts += productResult.updatedProducts;
result.createdPrices += productResult.createdPrices;
result.updatedPrices += productResult.updatedPrices;
result.deletedFeatures += productResult.deletedFeatures;
result.createdFeatures += productResult.createdFeatures;
await emitDiagnostic(diagnostics, diagnosticFromResult("plan-seeded", result, product.code));
}
await emitDiagnostic(diagnostics, diagnosticFromResult("success", result));
return result;
} catch (error) {
await emitDiagnostic(diagnostics, {
...diagnosticFromResult("failure", result),
error: redactSeedError(error),
});
throw error;
}
}