Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/utils/services/.server/subscriptionService.ts
T
2026-07-08 16:15:37 +02:00

540 lines
20 KiB
TypeScript

import { Prisma, SubscriptionPrice } from "@hivegrid/db/prisma-browser";
import { DefaultFeatures } from "~/application/dtos/shared/DefaultFeatures";
import { PlanFeatureUsageDto } from "~/application/dtos/subscriptions/PlanFeatureUsageDto";
import { SubscriptionFeatureDto } from "~/application/dtos/subscriptions/SubscriptionFeatureDto";
import { SubscriptionBillingPeriod } from "~/application/enums/subscriptions/SubscriptionBillingPeriod";
import { SubscriptionFeatureLimitType } from "~/application/enums/subscriptions/SubscriptionFeatureLimitType";
import currencies from "~/application/pricing/currencies";
import { db } from "../../db.server";
import { getAllSubscriptionFeatures } from "../../db/subscriptionProducts.db.server";
import {
createTenantSubscriptionUsageRecord,
listTenantSubscriptionIds,
updateTenantSubscriptionProduct,
type TenantSubscriptionWithDetails,
} from "@hivegrid/db/subscriptions.server";
import { getTenantSubscription, getTenantSubscriptions } from "../../db/tenantSubscriptions.db.server";
import { sendEmail } from "~/modules/emails/services/EmailService";
import { apiKeyCreditableStatusCodes, apiKeyIgnoreEndpoints } from "../../helpers/ApiKeyHelper";
import { getBaseURL } from "../../url.server";
import { cachified, clearCacheKey } from "../../cache.server";
import { getSubscriptionCache } from "./subscriptionCache.server";
import DateUtils from "~/utils/shared/DateUtils";
import { TFunction } from "i18next";
import { cancelTenantSubscriptionProduct, getTenantSubscriptionProductById } from "~/utils/db/subscriptions/tenantSubscriptionProducts.db.server";
import { SubscriptionCancelledDto } from "~/modules/events/dtos/SubscriptionCancelledDto";
import EventsService from "~/modules/events/services/.server/EventsService";
import { getTenant } from "~/utils/db/tenants.db.server";
import { getUser } from "~/utils/db/users.db.server";
import EmailTemplates from "~/modules/emails/utils/EmailTemplates";
import { getMailTranslatorFromRequest } from "~/locale/mail-translator.server";
import { getAppConfiguration } from "~/utils/db/appConfiguration.db.server";
function getActiveTenantSubscriptionProducts(subscription: TenantSubscriptionWithDetails | null): TenantSubscriptionWithDetails["products"] {
const now = Date.now();
return subscription?.products.filter((product) => !product.endsAt || new Date(product.endsAt).getTime() > now) ?? [];
}
export async function getPlanFeaturesUsage(tenantId: string, tenantSubscription?: TenantSubscriptionWithDetails | null): Promise<PlanFeatureUsageDto[]> {
let subscription: TenantSubscriptionWithDetails | null = null;
if (tenantSubscription === undefined) {
subscription = await getActiveTenantSubscriptions(tenantId);
} else {
subscription = tenantSubscription;
}
const myUsage: PlanFeatureUsageDto[] = [];
let allFeatures: SubscriptionFeatureDto[] = [];
const features: { name: string; code?: string | null; order: number; title: string; type: SubscriptionFeatureLimitType; value: number; accumulate: boolean }[] =
await getAllSubscriptionFeatures();
features
.filter((f) => (f.code || f.name) && (f.code || f.name) !== DefaultFeatures.Credits)
.forEach((feature) => {
const featureName = feature.code || feature.name;
const existing = allFeatures.find((f) => f.name === featureName);
if (!existing) {
allFeatures.push({
order: feature.order,
name: featureName,
title: feature.title,
type: feature.type,
value: feature.value,
accumulate: feature.accumulate,
});
}
});
allFeatures = allFeatures.sort((a, b) => a.order - b.order);
await Promise.all(
allFeatures.map(async (item) => {
let myFeatures: SubscriptionFeatureDto[] = [];
const activeProducts = getActiveTenantSubscriptionProducts(subscription);
activeProducts.forEach((product) => {
const feature = product.subscriptionProduct.features.find((f) => f.name === item.name);
if (feature) {
if (!product.quantity) {
myFeatures.push(feature);
} else {
// per-seat or one-time multiplication
for (let idx = 0; idx < product.quantity; idx++) {
myFeatures.push(feature);
}
}
}
});
const existingSubscriptionFeature = mergeFeatures(myFeatures);
const feature = existingSubscriptionFeature ?? item;
const usage: PlanFeatureUsageDto = {
order: feature.order,
title: feature.title,
name: feature.name,
type: feature.type,
value: feature.value,
used: 0,
remaining: 0,
enabled: feature.type !== SubscriptionFeatureLimitType.NOT_INCLUDED,
message: "",
};
if (!existingSubscriptionFeature) {
usage.type = SubscriptionFeatureLimitType.NOT_INCLUDED;
usage.enabled = false;
if (activeProducts.length > 0) {
usage.message = "featureLimits.upgradeSubscription";
} else {
usage.message = "featureLimits.noSubscription";
}
} else {
if (feature.type === SubscriptionFeatureLimitType.NOT_INCLUDED) {
usage.enabled = false;
usage.message = "featureLimits.notIncluded";
} else if (feature.type === SubscriptionFeatureLimitType.MAX) {
usage.used = await getUsed(tenantId, feature, subscription);
usage.remaining = usage.value - usage.used;
if (usage.remaining <= 0) {
usage.message = `You've reached the limit (${usage.used}/${usage.value}) for ${feature.name}`;
usage.enabled = false;
}
} else if (feature.type === SubscriptionFeatureLimitType.MONTHLY) {
usage.used = await getUsed(tenantId, feature, subscription);
usage.remaining = usage.value - usage.used;
usage.period = getUsedPeriod(subscription);
if (usage.remaining <= 0) {
// var now = new Date();
// const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, 1);
usage.message = `You've reached the limit this month (${usage.used}/${usage.value}) for ${feature.name}`;
usage.enabled = false;
}
} else if (feature.type === SubscriptionFeatureLimitType.UNLIMITED) {
usage.remaining = "unlimited";
}
}
myUsage.push(usage);
})
);
return myUsage.sort((a, b) => a.order - b.order);
}
function mergeFeatures(features: SubscriptionFeatureDto[]) {
if (features.length === 0) {
return undefined;
}
const mergedFeature: SubscriptionFeatureDto = {
order: features[0].order,
title: features[0].title,
name: features[0].name,
type: SubscriptionFeatureLimitType.NOT_INCLUDED,
value: 0,
accumulate: features[0].accumulate,
};
let firstFeature = true;
features.forEach((feature) => {
if (mergedFeature.type < feature.type) {
mergedFeature.type = feature.type;
}
// console.log({ mergedFeature });
if (mergedFeature.accumulate || firstFeature) {
mergedFeature.value += feature.value;
}
firstFeature = false;
});
return mergedFeature;
}
export async function getPlanFeatureUsage(
tenantId: string,
featureName: string,
tenantSubscription?: TenantSubscriptionWithDetails | null
): Promise<PlanFeatureUsageDto | undefined> {
const usage = await getPlanFeaturesUsage(tenantId, tenantSubscription);
return usage.find((f) => f.name === featureName);
}
function getUsedPeriod(subscription: TenantSubscriptionWithDetails | null) {
const date = new Date(),
y = date.getFullYear(),
m = date.getMonth();
let firstDay = new Date(y, m, 1, 0, 0, 1);
let lastDay = new Date(y, m + 1, 0, 23, 59, 59);
// if it's december, last day is january 0
if (m === 11) {
lastDay = new Date(y + 1, 0, 0, 23, 59, 59);
}
getActiveTenantSubscriptionProducts(subscription).forEach((product) => {
if (product.currentPeriodStart && product.currentPeriodEnd) {
firstDay = product.currentPeriodStart;
lastDay = product.currentPeriodEnd;
}
});
return {
firstDay,
lastDay,
};
}
async function getUsed(tenantId: string, feature: SubscriptionFeatureDto, subscription: TenantSubscriptionWithDetails | null): Promise<number> {
const { firstDay, lastDay } = await getUsedPeriod(subscription);
if (feature.name === DefaultFeatures.Users) {
if (feature.type === SubscriptionFeatureLimitType.MONTHLY) {
return await db.tenantUser.count({
where: {
tenantId,
createdAt: {
gte: firstDay,
lt: lastDay,
},
},
});
} else if (feature.type === SubscriptionFeatureLimitType.MAX) {
return await db.tenantUser.count({
where: {
tenantId,
},
});
}
} else if (feature.name === DefaultFeatures.API) {
if (feature.type === SubscriptionFeatureLimitType.MONTHLY) {
return await db.apiKeyLog.count({
where: {
tenantId,
status: { in: apiKeyCreditableStatusCodes },
endpoint: { notIn: apiKeyIgnoreEndpoints },
createdAt: {
gte: firstDay,
lt: lastDay,
},
},
});
} else if (feature.type === SubscriptionFeatureLimitType.MAX) {
return await db.apiKeyLog.count({
where: {
tenantId,
status: { in: apiKeyCreditableStatusCodes },
endpoint: { notIn: apiKeyIgnoreEndpoints },
},
});
}
} else if (feature.name === DefaultFeatures.Credits) {
if (feature.type === SubscriptionFeatureLimitType.MONTHLY) {
return await getSpentCredits({
tenantId,
createdAt: {
gte: firstDay,
lt: lastDay,
},
});
} else if (feature.type === SubscriptionFeatureLimitType.MAX) {
return await getSpentCredits({ tenantId });
}
}
// Entity-based feature usage was tracked through the generic entity-builder,
// which has been removed. Such features no longer have a row-based usage count.
return 0;
}
async function getSpentCredits(where: Prisma.CreditWhereInput): Promise<number> {
const spent = await db.credit.aggregate({
where: {
...where,
amount: { lt: 0 },
},
_sum: {
amount: true,
},
});
return Math.abs(spent._sum.amount ?? 0);
}
// export async function getPlanFeatureUsage(tenantId: string, featureName: string): Promise<PlanFeatureUsageDto> {
// const myUsage: PlanFeatureUsageDto[] = [];
// let allFeatures: SubscriptionFeatureDto[] = [];
// const features = await getAllSubscriptionFeatures();
// features.forEach((feature) => {
// const existing = allFeatures.find((f) => f.name === feature.name);
// if (!existing) {
// allFeatures.push({
// order: feature.order,
// name: feature.name,
// title: feature.title,
// type: feature.type,
// value: feature.value,
// });
// }
// });
// allFeatures = allFeatures.sort((a, b) => a.order - b.order);
// allFeatures.forEach((feature) => {
// const featureUsage: PlanFeatureUsageDto = {
// order: feature.order,
// title: feature.title,
// name: feature.name,
// type: feature.type,
// value: feature.value,
// used: 0,
// remaining: 0,
// };
// if (feature.type === SubscriptionFeatureLimitType.MAX) {
// featureUsage.used = 2;
// featureUsage.remaining = featureUsage.value - featureUsage.used;
// } else if (feature.type === SubscriptionFeatureLimitType.MONTHLY) {
// featureUsage.used = 3;
// featureUsage.remaining = featureUsage.value - featureUsage.used;
// }
// myUsage.push(featureUsage);
// });
// return myUsage;
// }
export async function getActiveTenantSubscriptions(tenantId: string) {
const mySubscription = await cachified({
key: `tenantSubscription:${tenantId}`,
ttl: 1000 * 60 * 60, // 1 hour
getFreshValue: () => getTenantSubscription(tenantId),
});
if (mySubscription) {
await Promise.all(
mySubscription.products.map(async (item) => {
if (item.billingProviderSubscriptionId) {
let currentPeriod =
item.currentPeriodStart && item.currentPeriodEnd
? {
start: DateUtils.getDateStartOfDay(item.currentPeriodStart),
end: DateUtils.getDateEndOfDay(item.currentPeriodEnd),
}
: undefined;
const today = new Date();
let todayIsInCurrentPeriod = false;
if (currentPeriod) {
todayIsInCurrentPeriod = today >= item.currentPeriodStart! && today <= item.currentPeriodEnd!;
}
if (currentPeriod && todayIsInCurrentPeriod) {
item.currentPeriodStart = currentPeriod.start;
item.currentPeriodEnd = currentPeriod.end;
} else {
const updatedItem = await updateTenantSubscriptionProduct({ id: item.id, tenantId: mySubscription.tenantId }, {
currentPeriodStart: item.currentPeriodStart,
currentPeriodEnd: item.currentPeriodEnd,
});
// Cross-replica purge: billing-period sync mutates the
// subscription, so peer web replicas must drop their L1 too —
// a bare clearCacheKey would only purge this process.
clearTenantSubscriptionCache(updatedItem.tenantSubscription.tenantId);
}
}
})
);
mySubscription.products = mySubscription.products.filter((f) => !f.endsAt || new Date(f.endsAt) > new Date());
mySubscription.products = mySubscription.products.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
}
return mySubscription;
}
export async function getActiveTenantsSubscriptions() {
const subscriptions = await getTenantSubscriptions();
return await Promise.all(
subscriptions.map(async (mySubscription) => {
await Promise.all(
mySubscription.products.map(async () => undefined)
);
mySubscription.products = mySubscription.products.filter((f) => !f.endsAt || new Date(f.endsAt) > new Date());
return mySubscription;
})
);
}
export async function reportUsage(tenantId: string, unit: string) {
const tenantSubscription = await getActiveTenantSubscriptions(tenantId);
if (!tenantSubscription) {
return;
}
await Promise.all(
tenantSubscription.products.map(async (product) => {
return await Promise.all(
product.prices.map(async (price) => {
if (price.subscriptionUsageBasedPrice?.unit === unit) {
await createTenantSubscriptionUsageRecord({
tenantId,
tenantSubscriptionId: tenantSubscription.id,
tenantSubscriptionProductPriceId: price.id,
metricCode: unit,
timestamp: Math.floor(Date.now() / 1000),
quantity: 1,
billingProviderSubscriptionItemId: null,
});
}
})
);
})
);
}
export async function persistCheckoutSessionStatus({
request,
id,
fromUrl,
fromUserId,
fromTenantId,
}: {
request: Request;
id: string;
fromUrl: string;
fromUserId?: string | null;
fromTenantId?: string | null;
}) {
void request;
void id;
void fromUrl;
void fromUserId;
void fromTenantId;
}
export async function getMrr(currency: string) {
const activeSubscriptions = await getActiveTenantsSubscriptions();
let summary: { total: number; count: number } = {
total: 0,
count: 0,
};
activeSubscriptions.forEach((s) => {
s.products.forEach((p) => {
summary.count++;
p.prices.forEach((f) => {
summary.total += getPriceInCurrency(f.subscriptionPrice, currency);
});
});
});
return summary;
}
function getPriceInCurrency(subscriptionPrice: SubscriptionPrice | null, currency: string) {
if (!subscriptionPrice) {
return 0;
}
let total = 0;
if (subscriptionPrice.billingPeriod === SubscriptionBillingPeriod.MONTHLY) {
total = Number(subscriptionPrice.price);
} else if (subscriptionPrice.billingPeriod === SubscriptionBillingPeriod.YEARLY) {
total = Number(subscriptionPrice.price) / 12;
} else if (subscriptionPrice.billingPeriod === SubscriptionBillingPeriod.WEEKLY) {
total = Number(subscriptionPrice.price) * 4;
} else if (subscriptionPrice.billingPeriod === SubscriptionBillingPeriod.DAILY) {
total = Number(subscriptionPrice.price) * 30;
}
if (currency !== subscriptionPrice.currency) {
total = convertToCurrency({ from: subscriptionPrice.currency, to: currency, price: total });
}
return total;
}
export function convertToCurrency({ from, price, to }: { from: string; price: number; to: string }): number {
const fromCurrency = currencies.find((f) => f.value === from);
const toCurrency = currencies.find((f) => f.value === to);
if (!fromCurrency || !toCurrency) {
return 0;
}
const fromParity = fromCurrency.parities?.find((f) => f.from === to);
const toParity = toCurrency.parities?.find((f) => f.from === from);
if (fromParity && fromParity.parity !== 0) {
return price / fromParity.parity;
} else if (toParity && toParity.parity !== 0) {
return price / toParity.parity;
}
return 0;
}
/**
* Invalidate the cached subscription for a single tenant. Prefer this over
* `clearAllSubscriptionsCache` whenever the change is tenant-scoped so we
* don't thrash every other tenant's cache entry.
*
* Publishes a cross-replica invalidation on the `cache:subscription:invalidate`
* channel via the two-tier cache so peer web replicas drop their L1 too.
* The publish is fire-and-forget — failures are logged but never thrown.
*/
export function clearTenantSubscriptionCache(tenantId: string) {
clearCacheKey(`tenantSubscription:${tenantId}`);
// Best-effort fan-out to peer replicas; never blocks the caller.
void getSubscriptionCache()
.invalidate(tenantId)
.catch(() => {
/* errors are logged inside the helper via its logger */
});
}
/**
* Invalidate every cached tenant subscription. Use only for global changes
* (plan/feature CRUD, bulk migrations). Also broadcasts a wildcard
* invalidation on the subscription pub/sub channel so peer replicas flush
* their L1 in one shot rather than per-tenant.
*/
export async function clearAllSubscriptionsCache() {
const tenantSubs = await listTenantSubscriptionIds();
tenantSubs.forEach((tenantSub) => {
clearCacheKey(`tenantSubscription:${tenantSub.tenantId}`);
});
// Wildcard fan-out — peer replicas flush their L1 entirely.
await getSubscriptionCache().invalidate().catch(() => {
/* logged inside helper */
});
}
export async function cancelTenantSubscription(
tenantSubscriptionProductId: string,
{ tenantId, userId, t }: { tenantId: string; userId: string; t?: TFunction }
) {
const tenantSubscriptionProduct = await getTenantSubscriptionProductById({ id: tenantSubscriptionProductId, tenantId });
if (!tenantSubscriptionProduct) {
throw new Error("Subscription product not found");
}
const user = userId ? await getUser(userId) : null;
const tenant = await getTenant(tenantId);
if (user && tenant) {
await EventsService.create({
event: "subscription.cancelled",
tenantId: tenant.id,
userId: user.id,
data: {
user: { id: user.id, email: user.email },
tenant: { id: tenant.id, name: tenant.name },
subscription: {
product: {
id: tenantSubscriptionProduct.subscriptionProductId,
title: t ? t(tenantSubscriptionProduct.subscriptionProduct.title) : tenantSubscriptionProduct.subscriptionProduct.title,
},
},
} satisfies SubscriptionCancelledDto,
});
}
await cancelTenantSubscriptionProduct(tenantSubscriptionProduct.id, tenantId, {
cancelledAt: new Date(),
endsAt: new Date(),
});
}