Open Source Wealth Management Software. Angular + NestJS + Prisma + Nx + TypeScript 🤍
TypeScript angularetffinancefintechghostfoliohacktoberfestinvestingnestjsosspersonal-financeportfolioprismasoftwarestocktrackertradingtypescriptwealth-managementweb
import { ConfigurationService } from '@ghostfolio/api/services/configuration/configuration.service';
import { PrismaService } from '@ghostfolio/api/services/prisma/prisma.service';
import { PropertyService } from '@ghostfolio/api/services/property/property.service';
import {
DEFAULT_LANGUAGE_CODE,
PROPERTY_STRIPE_CONFIG,
SUPPORTED_LANGUAGE_CODES
} from '@ghostfolio/common/config';
import { SubscriptionType } from '@ghostfolio/common/enums';
import { parseDate } from '@ghostfolio/common/helper';
import {
CreateStripeCheckoutSessionResponse,
SubscriptionOffer
} from '@ghostfolio/common/interfaces';
import {
SubscriptionOfferKey,
UserWithSettings
} from '@ghostfolio/common/types';
import { BadRequestException, Injectable, Logger } from '@nestjs/common';
import { Prisma, Subscription } from '@prisma/client';
import { addMilliseconds, isBefore } from 'date-fns';
import ms, { StringValue } from 'ms';
import Stripe from 'stripe';
@Injectable()
export class SubscriptionService {
private readonly logger = new Logger(SubscriptionService.name);
private stripe: Stripe;
public constructor(
private readonly configurationService: ConfigurationService,
private readonly prismaService: PrismaService,
private readonly propertyService: PropertyService
) {
if (this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
this.stripe = new Stripe(
this.configurationService.get('STRIPE_SECRET_KEY'),
{
apiVersion: '2026-09-30.endive'
}
);
}
}
public async createStripeCheckoutSession({
couponId,
priceId,
user
}: {
couponId?: string;
priceId: string;
user: UserWithSettings;
}): Promise<CreateStripeCheckoutSessionResponse> {
if (!priceId) {
throw new BadRequestException('Invalid priceId');
}
const subscriptionOffers: {
[offer in SubscriptionOfferKey]: SubscriptionOffer;
} =
(await this.propertyService.getByKey<any>(PROPERTY_STRIPE_CONFIG)) ?? {};
const subscriptionOffersForPrice = Object.values(subscriptionOffers).filter(
(subscriptionOffer) => {
return subscriptionOffer.priceId === priceId;
}
);
if (subscriptionOffersForPrice.length === 0) {
throw new BadRequestException('Invalid priceId');
}
const subscriptionOffer = subscriptionOffersForPrice.find(
(subscriptionOffer) => {
return subscriptionOffer.couponId === couponId;
}
);
if (!subscriptionOffer) {
throw new BadRequestException('Invalid couponId');
}
const stripeCheckoutSessionCreateParams: Stripe.Checkout.SessionCreateParams =
{
allowed_payment_method_types: ['card'],
cancel_url: `${this.configurationService.get('ROOT_URL')}/${
user.settings?.settings?.language ?? DEFAULT_LANGUAGE_CODE
}/account`,
client_reference_id: user.id,
line_items: [
{
price: priceId,
quantity: 1
}
],
locale: this.getStripeLocale(user.settings?.settings?.language),
metadata: { subscriptionOffer: JSON.stringify(subscriptionOffer) },
mode: 'payment',
success_url: `${this.configurationService.get(
'ROOT_URL'
)}/api/v1/subscription/stripe/callback?checkoutSessionId={CHECKOUT_SESSION_ID}`
};
if (couponId) {
stripeCheckoutSessionCreateParams.discounts = [
{
coupon: couponId
}
];
}
const session = await this.stripe.checkout.sessions.create(
stripeCheckoutSessionCreateParams
);
if (!session.url) {
throw new Error(`Stripe Checkout Session '${session.id}' is missing url`);
}
return {
sessionUrl: session.url
};
}
public async createSubscription({
duration = '1 year',
durationExtension,
price,
stripeCheckoutSessionId,
userId
}: {
duration?: StringValue;
durationExtension?: StringValue;
price: number;
stripeCheckoutSessionId?: string;
userId: string;
}) {
let expiresAt = addMilliseconds(new Date(), ms(duration));
if (durationExtension) {
expiresAt = addMilliseconds(expiresAt, ms(durationExtension));
}
await this.prismaService.subscription.create({
data: {
expiresAt,
price,
stripeCheckoutSessionId,
user: {
connect: {
id: userId
}
}
}
});
}
public async createSubscriptionViaStripe(aCheckoutSessionId: string) {
try {
const session =
await this.stripe.checkout.sessions.retrieve(aCheckoutSessionId);
if (session.payment_status !== 'paid' || session.status !== 'complete') {
throw new Error(
`Stripe Checkout Session '${aCheckoutSessionId}' has not been paid (status=${session.status}, payment_status=${session.payment_status})`
);
}
const subscriptionOffer: SubscriptionOffer = JSON.parse(
session.metadata?.subscriptionOffer ?? '{}'
);
const durationExtension = subscriptionOffer?.durationExtension;
if (!session.client_reference_id) {
throw new Error(
`Stripe Checkout Session '${aCheckoutSessionId}' is missing client_reference_id`
);
}
try {
await this.createSubscription({
durationExtension,
price: (session.amount_total ?? 0) / 100,
stripeCheckoutSessionId: session.id,
userId: session.client_reference_id
});
} catch (error) {
if (
error instanceof Prisma.PrismaClientKnownRequestError &&
error.code === 'P2002'
) {
this.logger.log(
`Stripe Checkout Session '${session.id}' has already been redeemed`
);
} else {
throw error;
}
}
return session.client_reference_id;
} catch (error) {
this.logger.error(error);
}
}
public async getSubscription({
createdAt,
subscriptions
}: {
createdAt: UserWithSettings['createdAt'];
subscriptions: Subscription[];
}): Promise<UserWithSettings['subscription']> {
if (subscriptions.length > 0) {
const { expiresAt, price } = subscriptions.reduce((a, b) => {
return new Date(a.expiresAt) > new Date(b.expiresAt) ? a : b;
});
const { createdAt: subscribedAt } = subscriptions.reduce((a, b) => {
return new Date(a.createdAt) < new Date(b.createdAt) ? a : b;
});
let offerKey: SubscriptionOfferKey = price ? 'renewal' : 'default';
if (createdAt && isBefore(createdAt, parseDate('2023-01-01')!)) {
offerKey = 'renewal-early-bird-2023';
} else if (createdAt && isBefore(createdAt, parseDate('2024-01-01')!)) {
offerKey = 'renewal-early-bird-2024';
} else if (createdAt && isBefore(createdAt, parseDate('2025-12-01')!)) {
offerKey = 'renewal-early-bird-2025';
}
const offer = await this.getSubscriptionOffer({
key: offerKey
});
return {
subscribedAt,
expiresAt: isBefore(new Date(), expiresAt) ? expiresAt : undefined,
offer: offer as SubscriptionOffer,
type: isBefore(new Date(), expiresAt)
? SubscriptionType.Premium
: SubscriptionType.Basic
};
} else {
const offer = await this.getSubscriptionOffer({
key: 'default'
});
return {
offer: offer as SubscriptionOffer,
type: SubscriptionType.Basic
};
}
}
public async getSubscriptionOffer({
key
}: {
key: SubscriptionOfferKey;
}): Promise<SubscriptionOffer | undefined> {
if (!this.configurationService.get('ENABLE_FEATURE_SUBSCRIPTION')) {
return undefined;
}
const offers: {
[offer in SubscriptionOfferKey]: SubscriptionOffer;
} =
(await this.propertyService.getByKey<any>(PROPERTY_STRIPE_CONFIG)) ?? {};
return {
...offers[key],
isRenewal: key.startsWith('renewal')
};
}
private getStripeLocale(
languageCode?: string
): Stripe.Checkout.SessionCreateParams.Locale {
const unsupportedLanguageCodes: Record<
Exclude<
(typeof SUPPORTED_LANGUAGE_CODES)[number],
// Extract keeps only the Stripe locales that Ghostfolio supports.
// This also removes OtherString, which matches every string.
Extract<
Stripe.Checkout.SessionCreateParams.Locale,
(typeof SUPPORTED_LANGUAGE_CODES)[number]
>
>,
true
> = {
ca: true,
uk: true
};
if (
languageCode &&
(SUPPORTED_LANGUAGE_CODES as readonly string[]).includes(languageCode) &&
!(languageCode in unsupportedLanguageCodes)
) {
return languageCode as Stripe.Checkout.SessionCreateParams.Locale;
}
return DEFAULT_LANGUAGE_CODE;
}
}