There can be more than Notion and Miro. AFFiNE(pronounced [ə‘fain]) is a next-gen knowledge base that brings planning, sorting and creating all together. Privacy first, open-source, customizable and ready to use.
TypeScript appcrdteditorelectronknowledge-basemarkdownmironotesnotionnotion-alternativerustrust-langrust-languagetabletableviewwhiteboardwikiworkspace
feat(server): support team workspace subscription (#8919)
forehalo5bf8ed1095fe
diff --git a/packages/backend/server/migrations/20241202070358_universal_subscription/migration.sql b/packages/backend/server/migrations/20241202070358_universal_subscription/migration.sqlnew file mode 100644index 0000000000..5c82cbd511--- /dev/null+++ b/packages/backend/server/migrations/20241202070358_universal_subscription/migration.sql@@ -0,0 +1,53 @@+-- DropForeignKey+ALTER TABLE "user_invoices" DROP CONSTRAINT "user_invoices_user_id_fkey";++-- DropForeignKey+ALTER TABLE "user_subscriptions" DROP CONSTRAINT "user_subscriptions_user_id_fkey";++-- CreateTable+CREATE TABLE "subscriptions" (+ "id" SERIAL NOT NULL,+ "target_id" VARCHAR NOT NULL,+ "plan" VARCHAR(20) NOT NULL,+ "recurring" VARCHAR(20) NOT NULL,+ "variant" VARCHAR(20),+ "quantity" INTEGER NOT NULL DEFAULT 1,+ "stripe_subscription_id" TEXT,+ "stripe_schedule_id" VARCHAR,+ "status" VARCHAR(20) NOT NULL,+ "start" TIMESTAMPTZ(3) NOT NULL,+ "end" TIMESTAMPTZ(3),+ "next_bill_at" TIMESTAMPTZ(3),+ "canceled_at" TIMESTAMPTZ(3),+ "trial_start" TIMESTAMPTZ(3),+ "trial_end" TIMESTAMPTZ(3),+ "created_at" TIMESTAMPTZ(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,+ "updated_at" TIMESTAMPTZ(3) NOT NULL,++ CONSTRAINT "subscriptions_pkey" PRIMARY KEY ("id")+);++-- CreateTable+CREATE TABLE "invoices" (+ "stripe_invoice_id" TEXT NOT NULL,+ "target_id" VARCHAR NOT NULL,+ "currency" VARCHAR(3) NOT NULL,+ "amount" INTEGER NOT NULL,+ "status" VARCHAR(20) NOT NULL,+ "created_at" TIMESTAMPTZ(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,+ "updated_at" TIMESTAMPTZ(3) NOT NULL,+ "reason" VARCHAR,+ "last_payment_error" TEXT,+ "link" TEXT,++ CONSTRAINT "invoices_pkey" PRIMARY KEY ("stripe_invoice_id")+);++-- CreateIndex+CREATE UNIQUE INDEX "subscriptions_stripe_subscription_id_key" ON "subscriptions"("stripe_subscription_id");++-- CreateIndex+CREATE UNIQUE INDEX "subscriptions_target_id_plan_key" ON "subscriptions"("target_id", "plan");++-- CreateIndex+CREATE INDEX "invoices_target_id_idx" ON "invoices"("target_id");diff --git a/packages/backend/server/schema.prisma b/packages/backend/server/schema.prismaindex 865a22a3b1..269cd8b372 100644--- a/packages/backend/server/schema.prisma+++ b/packages/backend/server/schema.prisma@@ -23,9 +23,7 @@ model User {registered Boolean @default(true)features UserFeature[]- customer UserStripeCustomer?- subscriptions UserSubscription[]- invoices UserInvoice[]+ userStripeCustomer UserStripeCustomer?workspacePermissions WorkspaceUserPermission[]pagePermissions WorkspacePageUserPermission[]connectedAccounts ConnectedAccount[]@@ -318,77 +316,6 @@ model SnapshotHistory {@@map("snapshot_histories")}-model UserStripeCustomer {- userId String @id @map("user_id") @db.VarChar- stripeCustomerId String @unique @map("stripe_customer_id") @db.VarChar- createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)-- user User @relation(fields: [userId], references: [id], onDelete: Cascade)-- @@map("user_stripe_customers")-}--model UserSubscription {- id Int @id @default(autoincrement()) @db.Integer- userId String @map("user_id") @db.VarChar- plan String @db.VarChar(20)- // yearly/monthly/lifetime- recurring String @db.VarChar(20)- // onetime subscription or anything else- variant String? @db.VarChar(20)- // subscription.id, null for linefetime payment or one time payment subscription- stripeSubscriptionId String? @unique @map("stripe_subscription_id")- // subscription.status, active/past_due/canceled/unpaid...- status String @db.VarChar(20)- // subscription.current_period_start- start DateTime @map("start") @db.Timestamptz(3)- // subscription.current_period_end, null for lifetime payment- end DateTime? @map("end") @db.Timestamptz(3)- // subscription.billing_cycle_anchor- nextBillAt DateTime? @map("next_bill_at") @db.Timestamptz(3)- // subscription.canceled_at- canceledAt DateTime? @map("canceled_at") @db.Timestamptz(3)- // subscription.trial_start- trialStart DateTime? @map("trial_start") @db.Timestamptz(3)- // subscription.trial_end- trialEnd DateTime? @map("trial_end") @db.Timestamptz(3)- stripeScheduleId String? @map("stripe_schedule_id") @db.VarChar-- createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)- updatedAt DateTime @updatedAt @map("updated_at") @db.Timestamptz(3)- user User @relation(fields: [userId], references: [id], onDelete: Cascade)-- @@unique([userId, plan])- @@map("user_subscriptions")-}--model UserInvoice {- id Int @id @default(autoincrement()) @db.Integer- userId String @map("user_id") @db.VarChar- stripeInvoiceId String @unique @map("stripe_invoice_id")- currency String @db.VarChar(3)- // CNY 12.50 stored as 1250- amount Int @db.Integer- status String @db.VarChar(20)- createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)- updatedAt DateTime @updatedAt @map("updated_at") @db.Timestamptz(3)- // billing reason- reason String? @db.VarChar- lastPaymentError String? @map("last_payment_error") @db.Text- // stripe hosted invoice link- link String? @db.Text-- // @deprecated- plan String? @db.VarChar(20)- // @deprecated- recurring String? @db.VarChar(20)-- user User @relation(fields: [userId], references: [id], onDelete: Cascade)-- @@index([userId])- @@map("user_invoices")-}-enum AiPromptRole {systemassistant@@ -503,3 +430,124 @@ model RuntimeConfig {@@unique([module, key])@@map("app_runtime_settings")}++model DeprecatedUserSubscription {+ id Int @id @default(autoincrement()) @db.Integer+ userId String @map("user_id") @db.VarChar+ plan String @db.VarChar(20)+ // yearly/monthly/lifetime+ recurring String @db.VarChar(20)+ // onetime subscription or anything else+ variant String? @db.VarChar(20)+ // subscription.id, null for lifetime payment or one time payment subscription+ stripeSubscriptionId String? @unique @map("stripe_subscription_id")+ // subscription.status, active/past_due/canceled/unpaid...+ status String @db.VarChar(20)+ // subscription.current_period_start+ start DateTime @map("start") @db.Timestamptz(3)+ // subscription.current_period_end, null for lifetime payment+ end DateTime? @map("end") @db.Timestamptz(3)+ // subscription.billing_cycle_anchor+ nextBillAt DateTime? @map("next_bill_at") @db.Timestamptz(3)+ // subscription.canceled_at+ canceledAt DateTime? @map("canceled_at") @db.Timestamptz(3)+ // subscription.trial_start+ trialStart DateTime? @map("trial_start") @db.Timestamptz(3)+ // subscription.trial_end+ trialEnd DateTime? @map("trial_end") @db.Timestamptz(3)+ stripeScheduleId String? @map("stripe_schedule_id") @db.VarChar++ createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)+ updatedAt DateTime @updatedAt @map("updated_at") @db.Timestamptz(3)++ @@unique([userId, plan])+ @@map("user_subscriptions")+}++model DeprecatedUserInvoice {+ id Int @id @default(autoincrement()) @db.Integer+ userId String @map("user_id") @db.VarChar+ stripeInvoiceId String @unique @map("stripe_invoice_id")+ currency String @db.VarChar(3)+ // CNY 12.50 stored as 1250+ amount Int @db.Integer+ status String @db.VarChar(20)+ createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)+ updatedAt DateTime @updatedAt @map("updated_at") @db.Timestamptz(3)+ // billing reason+ reason String? @db.VarChar+ lastPaymentError String? @map("last_payment_error") @db.Text+ // stripe hosted invoice link+ link String? @db.Text++ // @deprecated+ plan String? @db.VarChar(20)+ // @deprecated+ recurring String? @db.VarChar(20)++ @@index([userId])+ @@map("user_invoices")+}++model UserStripeCustomer {+ userId String @id @map("user_id") @db.VarChar+ stripeCustomerId String @unique @map("stripe_customer_id") @db.VarChar+ createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)++ user User @relation(fields: [userId], references: [id], onDelete: Cascade)++ @@map("user_stripe_customers")+}++model Subscription {+ id Int @id @default(autoincrement()) @db.Integer+ targetId String @map("target_id") @db.VarChar+ plan String @db.VarChar(20)+ // yearly/monthly/lifetime+ recurring String @db.VarChar(20)+ // onetime subscription or anything else+ variant String? @db.VarChar(20)+ quantity Int @default(1) @db.Integer+ // subscription.id, null for lifetime payment or one time payment subscription+ stripeSubscriptionId String? @unique @map("stripe_subscription_id")+ // stripe schedule id+ stripeScheduleId String? @map("stripe_schedule_id") @db.VarChar+ // subscription.status, active/past_due/canceled/unpaid...+ status String @db.VarChar(20)+ // subscription.current_period_start+ start DateTime @map("start") @db.Timestamptz(3)+ // subscription.current_period_end, null for lifetime payment+ end DateTime? @map("end") @db.Timestamptz(3)+ // subscription.billing_cycle_anchor+ nextBillAt DateTime? @map("next_bill_at") @db.Timestamptz(3)+ // subscription.canceled_at+ canceledAt DateTime? @map("canceled_at") @db.Timestamptz(3)+ // subscription.trial_start+ trialStart DateTime? @map("trial_start") @db.Timestamptz(3)+ // subscription.trial_end+ trialEnd DateTime? @map("trial_end") @db.Timestamptz(3)+ createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)+ updatedAt DateTime @updatedAt @map("updated_at") @db.Timestamptz(3)++ @@unique([targetId, plan])+ @@map("subscriptions")+}++model Invoice {+ stripeInvoiceId String @id @map("stripe_invoice_id")+ targetId String @map("target_id") @db.VarChar+ currency String @db.VarChar(3)+ // CNY 12.50 stored as 1250+ amount Int @db.Integer+ status String @db.VarChar(20)+ createdAt DateTime @default(now()) @map("created_at") @db.Timestamptz(3)+ updatedAt DateTime @updatedAt @map("updated_at") @db.Timestamptz(3)+ // billing reason+ reason String? @db.VarChar+ lastPaymentError String? @map("last_payment_error") @db.Text+ // stripe hosted invoice link+ link String? @db.Text++ @@index([targetId])+ @@map("invoices")+}diff --git a/packages/backend/server/src/core/user/resolver.ts b/packages/backend/server/src/core/user/resolver.tsindex 00723651f2..4eba70f6da 100644--- a/packages/backend/server/src/core/user/resolver.ts+++ b/packages/backend/server/src/core/user/resolver.ts@@ -5,7 +5,6 @@ import {Int,Mutation,Query,- ResolveField,Resolver,} from '@nestjs/graphql';import { PrismaClient } from '@prisma/client';@@ -37,7 +36,6 @@ import {@Resolver(() => UserType)export class UserResolver {constructor(- private readonly prisma: PrismaClient,private readonly storage: AvatarStorage,private readonly users: UserService) {}@@ -72,16 +70,6 @@ export class UserResolver {};}- @ResolveField(() => Int, {- name: 'invoiceCount',- description: 'Get user invoice count',- })- async invoiceCount(@CurrentUser() user: CurrentUser) {- return this.prisma.userInvoice.count({- where: { userId: user.id },- });- }-@Mutation(() => UserType, {name: 'uploadAvatar',description: 'Upload user avatar',diff --git a/packages/backend/server/src/core/workspaces/index.ts b/packages/backend/server/src/core/workspaces/index.tsindex f100a953ca..78d6e70738 100644--- a/packages/backend/server/src/core/workspaces/index.ts+++ b/packages/backend/server/src/core/workspaces/index.ts@@ -37,4 +37,4 @@ import {})export class WorkspaceModule {}-export type { InvitationType, WorkspaceType } from './types';+export { InvitationType, WorkspaceType } from './types';diff --git a/packages/backend/server/src/data/migrations/1733125339942-universal-subscription.ts b/packages/backend/server/src/data/migrations/1733125339942-universal-subscription.tsnew file mode 100644index 0000000000..8233c57877--- /dev/null+++ b/packages/backend/server/src/data/migrations/1733125339942-universal-subscription.ts@@ -0,0 +1,29 @@+import { PrismaClient } from '@prisma/client';++import { loop } from './utils/loop';++export class UniversalSubscription1733125339942 {+ // do the migration+ static async up(db: PrismaClient) {+ await loop(async (offset, take) => {+ const oldSubscriptions = await db.deprecatedUserSubscription.findMany({+ skip: offset,+ take,+ });++ await db.subscription.createMany({+ data: oldSubscriptions.map(s => ({+ targetId: s.userId,+ ...s,+ })),+ });++ return oldSubscriptions.length;+ }, 50);+ }++ // revert the migration+ static async down(_db: PrismaClient) {+ // noop+ }+}diff --git a/packages/backend/server/src/fundamentals/config/index.ts b/packages/backend/server/src/fundamentals/config/index.tsindex 826d20b5be..91afcdbf1a 100644--- a/packages/backend/server/src/fundamentals/config/index.ts+++ b/packages/backend/server/src/fundamentals/config/index.ts@@ -36,3 +36,5 @@ export class ConfigModule {};};}++export { Runtime };diff --git a/packages/backend/server/src/fundamentals/error/def.ts b/packages/backend/server/src/fundamentals/error/def.tsindex 10403ee477..385eebd3fc 100644--- a/packages/backend/server/src/fundamentals/error/def.ts+++ b/packages/backend/server/src/fundamentals/error/def.ts@@ -412,15 +412,28 @@ export const USER_FRIENDLY_ERRORS = {},// Subscription Errors+ unsupported_subscription_plan: {+ type: 'invalid_input',+ args: { plan: 'string' },+ message: ({ plan }) => `Unsupported subscription plan: ${plan}.`,+ },failed_to_checkout: {type: 'internal_server_error',message: 'Failed to create checkout session.',},+ invalid_checkout_parameters: {+ type: 'invalid_input',+ message: 'Invalid checkout parameters provided.',+ },subscription_already_exists: {type: 'resource_already_exists',args: { plan: 'string' },message: ({ plan }) => `You have already subscribed to the ${plan} plan.`,},+ invalid_subscription_parameters: {+ type: 'invalid_input',+ message: 'Invalid subscription parameters provided.',+ },subscription_not_exists: {type: 'resource_not_found',args: { plan: 'string' },@@ -430,6 +443,10 @@ export const USER_FRIENDLY_ERRORS = {type: 'action_forbidden',message: 'Your subscription has already been canceled.',},+ subscription_has_not_been_canceled: {+ type: 'action_forbidden',+ message: 'Your subscription has not been canceled.',+ },subscription_expired: {type: 'action_forbidden',message: 'Your subscription has expired.',@@ -453,6 +470,14 @@ export const USER_FRIENDLY_ERRORS = {type: 'action_forbidden',message: 'You cannot update an onetime payment subscription.',},+ workspace_id_required_for_team_subscription: {+ type: 'invalid_input',+ message: 'A workspace is required to checkout for team subscription.',+ },+ workspace_id_required_to_update_team_subscription: {+ type: 'invalid_input',+ message: 'Workspace id is required to update team subscription.',+ },// Copilot errorscopilot_session_not_found: {diff --git a/packages/backend/server/src/fundamentals/error/errors.gen.ts b/packages/backend/server/src/fundamentals/error/errors.gen.tsindex ed05069704..c3212d71cc 100644--- a/packages/backend/server/src/fundamentals/error/errors.gen.ts+++ b/packages/backend/server/src/fundamentals/error/errors.gen.ts@@ -328,12 +328,28 @@ export class FailedToUpsertSnapshot extends UserFriendlyError {super('internal_server_error', 'failed_to_upsert_snapshot', message);}}+@ObjectType()+class UnsupportedSubscriptionPlanDataType {+ @Field() plan!: string+}++export class UnsupportedSubscriptionPlan extends UserFriendlyError {+ constructor(args: UnsupportedSubscriptionPlanDataType, message?: string | ((args: UnsupportedSubscriptionPlanDataType) => string)) {+ super('invalid_input', 'unsupported_subscription_plan', message, args);+ }+}export class FailedToCheckout extends UserFriendlyError {constructor(message?: string) {super('internal_server_error', 'failed_to_checkout', message);}}++export class InvalidCheckoutParameters extends UserFriendlyError {+ constructor(message?: string) {+ super('invalid_input', 'invalid_checkout_parameters', message);+ }+}@ObjectType()class SubscriptionAlreadyExistsDataType {@Field() plan!: string@@ -344,6 +360,12 @@ export class SubscriptionAlreadyExists extends UserFriendlyError {super('resource_already_exists', 'subscription_already_exists', message, args);}}++export class InvalidSubscriptionParameters extends UserFriendlyError {+ constructor(message?: string) {+ super('invalid_input', 'invalid_subscription_parameters', message);+ }+}@ObjectType()class SubscriptionNotExistsDataType {@Field() plan!: string@@ -361,6 +383,12 @@ export class SubscriptionHasBeenCanceled extends UserFriendlyError {}}+export class SubscriptionHasNotBeenCanceled extends UserFriendlyError {+ constructor(message?: string) {+ super('action_forbidden', 'subscription_has_not_been_canceled', message);+ }+}+export class SubscriptionExpired extends UserFriendlyError {constructor(message?: string) {super('action_forbidden', 'subscription_expired', message);@@ -400,6 +428,18 @@ export class CantUpdateOnetimePaymentSubscription extends UserFriendlyError {}}+export class WorkspaceIdRequiredForTeamSubscription extends UserFriendlyError {+ constructor(message?: string) {+ super('invalid_input', 'workspace_id_required_for_team_subscription', message);+ }+}++export class WorkspaceIdRequiredToUpdateTeamSubscription extends UserFriendlyError {+ constructor(message?: string) {+ super('invalid_input', 'workspace_id_required_to_update_team_subscription', message);+ }+}+export class CopilotSessionNotFound extends UserFriendlyError {constructor(message?: string) {super('resource_not_found', 'copilot_session_not_found', message);@@ -587,15 +627,21 @@ export enum ErrorNames {PAGE_IS_NOT_PUBLIC,FAILED_TO_SAVE_UPDATES,FAILED_TO_UPSERT_SNAPSHOT,+ UNSUPPORTED_SUBSCRIPTION_PLAN,FAILED_TO_CHECKOUT,+ INVALID_CHECKOUT_PARAMETERS,SUBSCRIPTION_ALREADY_EXISTS,+ INVALID_SUBSCRIPTION_PARAMETERS,SUBSCRIPTION_NOT_EXISTS,SUBSCRIPTION_HAS_BEEN_CANCELED,+ SUBSCRIPTION_HAS_NOT_BEEN_CANCELED,SUBSCRIPTION_EXPIRED,SAME_SUBSCRIPTION_RECURRING,CUSTOMER_PORTAL_CREATE_FAILED,SUBSCRIPTION_PLAN_NOT_FOUND,CANT_UPDATE_ONETIME_PAYMENT_SUBSCRIPTION,+ WORKSPACE_ID_REQUIRED_FOR_TEAM_SUBSCRIPTION,+ WORKSPACE_ID_REQUIRED_TO_UPDATE_TEAM_SUBSCRIPTION,COPILOT_SESSION_NOT_FOUND,COPILOT_SESSION_DELETED,NO_COPILOT_PROVIDER_AVAILABLE,@@ -624,5 +670,5 @@ registerEnumType(ErrorNames, {export const ErrorDataUnionType = createUnionType({name: 'ErrorDataUnion',types: () =>- [UnknownOauthProviderDataType, MissingOauthQueryParameterDataType, InvalidEmailDataType, InvalidPasswordLengthDataType, SpaceNotFoundDataType, NotInSpaceDataType, AlreadyInSpaceDataType, SpaceAccessDeniedDataType, SpaceOwnerNotFoundDataType, DocNotFoundDataType, DocAccessDeniedDataType, VersionRejectedDataType, InvalidHistoryTimestampDataType, DocHistoryNotFoundDataType, BlobNotFoundDataType, SubscriptionAlreadyExistsDataType, SubscriptionNotExistsDataType, SameSubscriptionRecurringDataType, SubscriptionPlanNotFoundDataType, CopilotMessageNotFoundDataType, CopilotPromptNotFoundDataType, CopilotProviderSideErrorDataType, RuntimeConfigNotFoundDataType, InvalidRuntimeConfigTypeDataType] as const,+ [UnknownOauthProviderDataType, MissingOauthQueryParameterDataType, InvalidEmailDataType, InvalidPasswordLengthDataType, SpaceNotFoundDataType, NotInSpaceDataType, AlreadyInSpaceDataType, SpaceAccessDeniedDataType, SpaceOwnerNotFoundDataType, DocNotFoundDataType, DocAccessDeniedDataType, VersionRejectedDataType, InvalidHistoryTimestampDataType, DocHistoryNotFoundDataType, BlobNotFoundDataType, UnsupportedSubscriptionPlanDataType, SubscriptionAlreadyExistsDataType, SubscriptionNotExistsDataType, SameSubscriptionRecurringDataType, SubscriptionPlanNotFoundDataType, CopilotMessageNotFoundDataType, CopilotPromptNotFoundDataType, CopilotProviderSideErrorDataType, RuntimeConfigNotFoundDataType, InvalidRuntimeConfigTypeDataType] as const,});diff --git a/packages/backend/server/src/plugins/payment/config.ts b/packages/backend/server/src/plugins/payment/config.tsindex 0c8c2101fa..707311b12f 100644--- a/packages/backend/server/src/plugins/payment/config.ts+++ b/packages/backend/server/src/plugins/payment/config.ts@@ -29,6 +29,6 @@ defineStartupConfig('plugins.payment', {});defineRuntimeConfig('plugins.payment', {showLifetimePrice: {desc: 'Whether enable lifetime price and allow user to pay for it.',- default: false,+ default: true,},});diff --git a/packages/backend/server/src/plugins/payment/cron.ts b/packages/backend/server/src/plugins/payment/cron.tsindex dacacaf824..9b96cd634a 100644--- a/packages/backend/server/src/plugins/payment/cron.ts+++ b/packages/backend/server/src/plugins/payment/cron.ts@@ -19,7 +19,7 @@ export class SubscriptionCronJobs {@Cron(CronExpression.EVERY_HOUR)async cleanExpiredOnetimeSubscriptions() {- const subscriptions = await this.db.userSubscription.findMany({+ const subscriptions = await this.db.subscription.findMany({where: {variant: SubscriptionVariant.Onetime,end: {@@ -30,7 +30,7 @@ export class SubscriptionCronJobs {for (const subscription of subscriptions) {this.event.emit('user.subscription.canceled', {- userId: subscription.userId,+ userId: subscription.targetId,plan: subscription.plan as SubscriptionPlan,recurring: subscription.variant as SubscriptionRecurring,});@@ -42,10 +42,10 @@ export class SubscriptionCronJobs {userId,plan,}: EventPayload<'user.subscription.canceled'>) {- await this.db.userSubscription.delete({+ await this.db.subscription.delete({where: {- userId_plan: {- userId,+ targetId_plan: {+ targetId: userId,plan,},},diff --git a/packages/backend/server/src/plugins/payment/index.ts b/packages/backend/server/src/plugins/payment/index.tsindex c7f85354e6..c59072bf43 100644--- a/packages/backend/server/src/plugins/payment/index.ts+++ b/packages/backend/server/src/plugins/payment/index.ts@@ -2,19 +2,27 @@ import './config';import { ServerFeature } from '../../core/config';import { FeatureModule } from '../../core/features';+import { PermissionModule } from '../../core/permission';import { UserModule } from '../../core/user';import { Plugin } from '../registry';import { StripeWebhookController } from './controller';import { SubscriptionCronJobs } from './cron';-import { UserSubscriptionManager } from './manager';-import { SubscriptionResolver, UserSubscriptionResolver } from './resolver';+import {+ UserSubscriptionManager,+ WorkspaceSubscriptionManager,+} from './manager';+import {+ SubscriptionResolver,+ UserSubscriptionResolver,+ WorkspaceSubscriptionResolver,+} from './resolver';import { SubscriptionService } from './service';import { StripeProvider } from './stripe';import { StripeWebhook } from './webhook';@Plugin({name: 'payment',- imports: [FeatureModule, UserModule],+ imports: [FeatureModule, UserModule, PermissionModule],providers: [StripeProvider,SubscriptionService,@@ -22,7 +30,9 @@ import { StripeWebhook } from './webhook';UserSubscriptionResolver,StripeWebhook,UserSubscriptionManager,+ WorkspaceSubscriptionManager,SubscriptionCronJobs,+ WorkspaceSubscriptionResolver,],controllers: [StripeWebhookController],requires: [diff --git a/packages/backend/server/src/plugins/payment/manager/common.ts b/packages/backend/server/src/plugins/payment/manager/common.tsindex 29336df980..c8d16e4191 100644--- a/packages/backend/server/src/plugins/payment/manager/common.ts+++ b/packages/backend/server/src/plugins/payment/manager/common.ts@@ -1,13 +1,23 @@-import { UserStripeCustomer } from '@prisma/client';+import { PrismaClient, UserStripeCustomer } from '@prisma/client';+import Stripe from 'stripe';+import { z } from 'zod';+import { UserNotFound } from '../../../fundamentals';+import { ScheduleManager } from '../schedule';import {+ encodeLookupKey,+ KnownStripeInvoice,KnownStripePrice,KnownStripeSubscription,+ LookupKey,SubscriptionPlan,SubscriptionRecurring,+ SubscriptionVariant,} from '../types';export interface Subscription {+ stripeSubscriptionId: string | null;+ stripeScheduleId: string | null;status: string;plan: string;recurring: string;@@ -21,36 +31,225 @@ export interface Subscription {}export interface Invoice {+ stripeInvoiceId: string;currency: string;amount: number;status: string;- createdAt: Date;+ reason: string | null;lastPaymentError: string | null;link: string | null;}-export interface SubscriptionManager {- filterPrices(+export const SubscriptionIdentity = z.object({+ plan: z.nativeEnum(SubscriptionPlan),+});++export const CheckoutParams = z.object({+ plan: z.nativeEnum(SubscriptionPlan),+ recurring: z.nativeEnum(SubscriptionRecurring),+ variant: z.nativeEnum(SubscriptionVariant).nullable().optional(),+ coupon: z.string().nullable().optional(),+ quantity: z.number().min(1).nullable().optional(),+ successCallbackLink: z.string(),+});++export abstract class SubscriptionManager {+ protected readonly scheduleManager = new ScheduleManager(this.stripe);+ constructor(+ protected readonly stripe: Stripe,+ protected readonly db: PrismaClient+ ) {}++ abstract filterPrices(prices: KnownStripePrice[],customer?: UserStripeCustomer- ): Promise<KnownStripePrice[]>;+ ): KnownStripePrice[] | Promise<KnownStripePrice[]>;++ abstract checkout(+ price: KnownStripePrice,+ params: z.infer<typeof CheckoutParams>,+ args: any+ ): Promise<Stripe.Checkout.Session>;- saveSubscription(+ abstract saveStripeSubscription(subscription: KnownStripeSubscription): Promise<Subscription>;- deleteSubscription(subscription: KnownStripeSubscription): Promise<void>;+ abstract deleteStripeSubscription(+ subscription: KnownStripeSubscription+ ): Promise<void>;- getSubscription(- id: string,- plan: SubscriptionPlan+ abstract getSubscription(+ identity: z.infer<typeof SubscriptionIdentity>): Promise<Subscription | null>;+ abstract cancelSubscription(+ subscription: Subscription+ ): Promise<Subscription>;- cancelSubscription(subscription: Subscription): Promise<Subscription>;-- resumeSubscription(subscription: Subscription): Promise<Subscription>;+ abstract resumeSubscription(+ subscription: Subscription+ ): Promise<Subscription>;- updateSubscriptionRecurring(+ abstract updateSubscriptionRecurring(subscription: Subscription,recurring: SubscriptionRecurring): Promise<Subscription>;++ abstract saveInvoice(knownInvoice: KnownStripeInvoice): Promise<Invoice>;++ transformSubscription({+ lookupKey,+ stripeSubscription: subscription,+ }: KnownStripeSubscription): Subscription {+ return {+ ...lookupKey,+ stripeScheduleId: subscription.schedule as string | null,+ stripeSubscriptionId: subscription.id,+ status: subscription.status,+ start: new Date(subscription.current_period_start * 1000),+ end: new Date(subscription.current_period_end * 1000),+ trialStart: subscription.trial_start+ ? new Date(subscription.trial_start * 1000)+ : null,+ trialEnd: subscription.trial_end+ ? new Date(subscription.trial_end * 1000)+ : null,+ nextBillAt: !subscription.canceled_at+ ? new Date(subscription.current_period_end * 1000)+ : null,+ canceledAt: subscription.canceled_at+ ? new Date(subscription.canceled_at * 1000)+ : null,+ };+ }++ async transformInvoice({+ stripeInvoice,+ }: KnownStripeInvoice): Promise<Invoice> {+ const status = stripeInvoice.status ?? 'void';+ let error: string | boolean | null = null;++ if (status !== 'paid') {+ if (stripeInvoice.last_finalization_error) {+ error = stripeInvoice.last_finalization_error.message ?? true;+ } else if (+ stripeInvoice.attempt_count > 1 &&+ stripeInvoice.payment_intent+ ) {+ const paymentIntent =+ typeof stripeInvoice.payment_intent === 'string'+ ? await this.stripe.paymentIntents.retrieve(+ stripeInvoice.payment_intent+ )+ : stripeInvoice.payment_intent;++ if (paymentIntent.last_payment_error) {+ error = paymentIntent.last_payment_error.message ?? true;+ }+ }+ }++ // fallback to generic error message+ if (error === true) {+ error = 'Payment Error. Please contact support.';+ }++ return {+ stripeInvoiceId: stripeInvoice.id,+ status,+ link: stripeInvoice.hosted_invoice_url || null,+ reason: stripeInvoice.billing_reason,+ amount: stripeInvoice.total,+ currency: stripeInvoice.currency,+ lastPaymentError: error,+ };+ }++ async getOrCreateCustomer(userId: string): Promise<UserStripeCustomer> {+ const user = await this.db.user.findUnique({+ where: {+ id: userId,+ },+ select: {+ email: true,+ userStripeCustomer: true,+ },+ });++ if (!user) {+ throw new UserNotFound();+ }++ let customer = user.userStripeCustomer;+ if (!customer) {+ const stripeCustomersList = await this.stripe.customers.list({+ email: user.email,+ limit: 1,+ });++ let stripeCustomer: Stripe.Customer | undefined;+ if (stripeCustomersList.data.length) {+ stripeCustomer = stripeCustomersList.data[0];+ } else {+ stripeCustomer = await this.stripe.customers.create({+ email: user.email,+ });+ }++ customer = await this.db.userStripeCustomer.create({+ data: {+ userId,+ stripeCustomerId: stripeCustomer.id,+ },+ });+ }++ return customer;+ }++ protected async getPrice(+ lookupKey: LookupKey+ ): Promise<KnownStripePrice | null> {+ const prices = await this.stripe.prices.list({+ lookup_keys: [encodeLookupKey(lookupKey)],+ limit: 1,+ });++ const price = prices.data[0];++ return price+ ? {+ lookupKey,+ price,+ }+ : null;+ }++ protected async getCouponFromPromotionCode(+ userFacingPromotionCode: string,+ customer: UserStripeCustomer+ ) {+ const list = await this.stripe.promotionCodes.list({+ code: userFacingPromotionCode,+ active: true,+ limit: 1,+ });++ const code = list.data[0];+ if (!code) {+ return null;+ }++ // the coupons are always bound to products, we need to check it first+ // but the logic would be too complicated, and stripe will complain if the code is not applicable when checking out+ // It's safe to skip the check here+ // code.coupon.applies_to.products.forEach()++ // check if the code is bound to a specific customer+ return !code.customer ||+ (typeof code.customer === 'string'+ ? code.customer === customer.stripeCustomerId+ : code.customer.id === customer.stripeCustomerId)+ ? code.coupon.id+ : null;+ }}diff --git a/packages/backend/server/src/plugins/payment/manager/index.ts b/packages/backend/server/src/plugins/payment/manager/index.tsindex 13c53c6d66..21d7a26a20 100644--- a/packages/backend/server/src/plugins/payment/manager/index.ts+++ b/packages/backend/server/src/plugins/payment/manager/index.ts@@ -1,2 +1,3 @@export * from './common';export * from './user';+export * from './workspace';diff --git a/packages/backend/server/src/plugins/payment/manager/user.ts b/packages/backend/server/src/plugins/payment/manager/user.tsindex be2103dea6..32b20c570d 100644--- a/packages/backend/server/src/plugins/payment/manager/user.ts+++ b/packages/backend/server/src/plugins/payment/manager/user.ts@@ -1,10 +1,8 @@import { Injectable } from '@nestjs/common';-import {- PrismaClient,- UserStripeCustomer,- UserSubscription,-} from '@prisma/client';+import { PrismaClient, UserStripeCustomer } from '@prisma/client';+import { omit, pick } from 'lodash-es';import Stripe from 'stripe';+import { z } from 'zod';import {EarlyAccessType,@@ -14,6 +12,9 @@ import {Config,EventEmitter,InternalServerError,+ SubscriptionAlreadyExists,+ SubscriptionPlanNotFound,+ URLHelper,} from '../../../fundamentals';import {CouponType,@@ -26,7 +27,7 @@ import {SubscriptionStatus,SubscriptionVariant,} from '../types';-import { SubscriptionManager } from './common';+import { CheckoutParams, Subscription, SubscriptionManager } from './common';interface PriceStrategyStatus {proEarlyAccess: boolean;@@ -36,15 +37,30 @@ interface PriceStrategyStatus {onetime: boolean;}+export const UserSubscriptionIdentity = z.object({+ plan: z.enum([SubscriptionPlan.Pro, SubscriptionPlan.AI]),+ userId: z.string(),+});++export const UserSubscriptionCheckoutArgs = z.object({+ user: z.object({+ id: z.string(),+ email: z.string(),+ }),+});+@Injectable()-export class UserSubscriptionManager implements SubscriptionManager {+export class UserSubscriptionManager extends SubscriptionManager {constructor(- private readonly db: PrismaClient,+ stripe: Stripe,+ db: PrismaClient,private readonly config: Config,- private readonly stripe: Stripe,private readonly feature: FeatureManagementService,- private readonly event: EventEmitter- ) {}+ private readonly event: EventEmitter,+ private readonly url: URLHelper+ ) {+ super(stripe, db);+ }async filterPrices(prices: KnownStripePrice[],@@ -71,11 +87,105 @@ export class UserSubscriptionManager implements SubscriptionManager {return availablePrices;}- async getSubscription(userId: string, plan: SubscriptionPlan) {- return this.db.userSubscription.findFirst({+ async checkout(+ price: KnownStripePrice,+ params: z.infer<typeof CheckoutParams>,+ { user }: z.infer<typeof UserSubscriptionCheckoutArgs>+ ) {+ const lookupKey = price.lookupKey;+ const subscription = await this.getSubscription({+ // @ts-expect-error filtered already+ plan: price.lookupKey.plan,+ user,+ });++ if (+ subscription &&+ // do not allow to re-subscribe unless+ !(+ /* current subscription is a onetime subscription and so as the one that's checking out */+ (+ (subscription.variant === SubscriptionVariant.Onetime &&+ lookupKey.variant === SubscriptionVariant.Onetime) ||+ /* current subscription is normal subscription and is checking-out a lifetime subscription */+ (subscription.recurring !== SubscriptionRecurring.Lifetime &&+ subscription.variant !== SubscriptionVariant.Onetime &&+ lookupKey.recurring === SubscriptionRecurring.Lifetime)+ )+ )+ ) {+ throw new SubscriptionAlreadyExists({ plan: lookupKey.plan });+ }++ const customer = await this.getOrCreateCustomer(user.id);+ const strategy = await this.strategyStatus(customer);+ const available = await this.isPriceAvailable(price, {+ ...strategy,+ onetime: true,+ });++ if (!available) {+ throw new SubscriptionPlanNotFound({+ plan: lookupKey.plan,+ recurring: lookupKey.recurring,+ });+ }++ const discounts = await (async () => {+ const coupon = await this.getBuildInCoupon(customer, price);+ if (coupon) {+ return { discounts: [{ coupon }] };+ } else if (params.coupon) {+ const couponId = await this.getCouponFromPromotionCode(+ params.coupon,+ customer+ );+ if (couponId) {+ return { discounts: [{ coupon: couponId }] };+ }+ }++ return { allow_promotion_codes: true };+ })();++ // mode: 'subscription' or 'payment' for lifetime and onetime payment+ const mode =+ lookupKey.recurring === SubscriptionRecurring.Lifetime ||+ lookupKey.variant === SubscriptionVariant.Onetime+ ? {+ mode: 'payment' as const,+ invoice_creation: {+ enabled: true,+ },+ }+ : {+ mode: 'subscription' as const,+ };++ return this.stripe.checkout.sessions.create({+ line_items: [+ {+ price: price.price.id,+ quantity: 1,+ },+ ],+ tax_id_collection: {+ enabled: true,+ },+ ...discounts,+ ...mode,+ success_url: this.url.link(params.successCallbackLink, {+ session_id: '{CHECKOUT_SESSION_ID}',+ }),+ customer: customer.stripeCustomerId,+ });+ }++ async getSubscription(args: z.infer<typeof UserSubscriptionIdentity>) {+ return this.db.subscription.findFirst({where: {- userId,- plan,+ targetId: args.userId,+ plan: args.plan,status: {in: [SubscriptionStatus.Active, SubscriptionStatus.Trialing],},@@ -83,11 +193,8 @@ export class UserSubscriptionManager implements SubscriptionManager {});}- async saveSubscription({- userId,- lookupKey,- stripeSubscription: subscription,- }: KnownStripeSubscription) {+ async saveStripeSubscription(subscription: KnownStripeSubscription) {+ const { userId, lookupKey, stripeSubscription } = subscription;// update features first, features modify are idempotent// so there is no need to skip if a subscription already exists.// TODO(@forehalo):@@ -99,43 +206,85 @@ export class UserSubscriptionManager implements SubscriptionManager {recurring: lookupKey.recurring,});- const commonData = {- status: subscription.status,- stripeScheduleId: subscription.schedule as string | null,- nextBillAt: !subscription.canceled_at- ? new Date(subscription.current_period_end * 1000)- : null,- canceledAt: subscription.canceled_at- ? new Date(subscription.canceled_at * 1000)- : null,- };+ const subscriptionData = this.transformSubscription(subscription);- return await this.db.userSubscription.upsert({+ // @deprecated backward compatibility+ await this.db.deprecatedUserSubscription.upsert({where: {- stripeSubscriptionId: subscription.id,+ stripeSubscriptionId: stripeSubscription.id,},- update: commonData,+ update: pick(subscriptionData, [+ 'status',+ 'stripeScheduleId',+ 'nextBillAt',+ 'canceledAt',+ ]),create: {userId,- ...lookupKey,- stripeSubscriptionId: subscription.id,- start: new Date(subscription.current_period_start * 1000),- end: new Date(subscription.current_period_end * 1000),- trialStart: subscription.trial_start- ? new Date(subscription.trial_start * 1000)- : null,- trialEnd: subscription.trial_end- ? new Date(subscription.trial_end * 1000)- : null,- ...commonData,+ ...subscriptionData,+ },+ });++ return this.db.subscription.upsert({+ where: {+ stripeSubscriptionId: stripeSubscription.id,+ },+ update: pick(subscriptionData, [+ 'status',+ 'stripeScheduleId',+ 'nextBillAt',+ 'canceledAt',+ ]),+ create: {+ targetId: userId,+ ...subscriptionData,},});}- async cancelSubscription(subscription: UserSubscription) {- return this.db.userSubscription.update({+ async deleteStripeSubscription({+ userId,+ lookupKey,+ stripeSubscription,+ }: KnownStripeSubscription) {+ const deleted = await this.db.subscription.deleteMany({where: {- id: subscription.id,+ stripeSubscriptionId: stripeSubscription.id,+ },+ });++ // @deprecated backward compatibility+ await this.db.deprecatedUserSubscription.deleteMany({+ where: {+ stripeSubscriptionId: stripeSubscription.id,+ },+ });++ if (deleted.count > 0) {+ this.event.emit('user.subscription.canceled', {+ userId,+ plan: lookupKey.plan,+ recurring: lookupKey.recurring,+ });+ }+ }++ async cancelSubscription(subscription: Subscription) {+ // @deprecated backward compatibility+ await this.db.deprecatedUserSubscription.updateMany({+ where: {+ stripeSubscriptionId: subscription.stripeSubscriptionId,+ },+ data: {+ canceledAt: new Date(),+ nextBillAt: null,+ },+ });++ return this.db.subscription.update({+ where: {+ // @ts-expect-error checked outside+ stripeSubscriptionId: subscription.stripeSubscriptionId,},data: {canceledAt: new Date(),@@ -144,9 +293,23 @@ export class UserSubscriptionManager implements SubscriptionManager {});}- async resumeSubscription(subscription: UserSubscription) {- return this.db.userSubscription.update({- where: { id: subscription.id },+ async resumeSubscription(subscription: Subscription) {+ // @deprecated backward compatibility+ await this.db.deprecatedUserSubscription.updateMany({+ where: {+ stripeSubscriptionId: subscription.stripeSubscriptionId,+ },+ data: {+ canceledAt: null,+ nextBillAt: subscription.end,+ },+ });++ return this.db.subscription.update({+ where: {+ // @ts-expect-error checked outside+ stripeSubscriptionId: subscription.stripeSubscriptionId,+ },data: {canceledAt: null,nextBillAt: subscription.end,@@ -155,34 +318,30 @@ export class UserSubscriptionManager implements SubscriptionManager {}async updateSubscriptionRecurring(- subscription: UserSubscription,+ subscription: Subscription,recurring: SubscriptionRecurring) {- return this.db.userSubscription.update({- where: { id: subscription.id },+ // @deprecated backward compatibility+ await this.db.deprecatedUserSubscription.updateMany({+ where: {+ stripeSubscriptionId: subscription.stripeSubscriptionId,+ },data: { recurring },});- }- async deleteSubscription({- userId,- lookupKey,- stripeSubscription,- }: KnownStripeSubscription) {- await this.db.userSubscription.delete({+ return this.db.subscription.update({where: {- stripeSubscriptionId: stripeSubscription.id,+ // @ts-expect-error checked outside+ stripeSubscriptionId: subscription.stripeSubscriptionId,},- });-- this.event.emit('user.subscription.canceled', {- userId,- plan: lookupKey.plan,- recurring: lookupKey.recurring,+ data: { recurring },});}- async validatePrice(price: KnownStripePrice, customer: UserStripeCustomer) {+ private async getBuildInCoupon(+ customer: UserStripeCustomer,+ price: KnownStripePrice+ ) {const strategyStatus = await this.strategyStatus(customer);// onetime price is allowed for checkout@@ -192,7 +351,7 @@ export class UserSubscriptionManager implements SubscriptionManager {return null;}- let coupon: CouponType | null = null;+ let coupon: CouponType | undefined;if (price.lookupKey.variant === SubscriptionVariant.EA) {if (price.lookupKey.plan === SubscriptionPlan.Pro) {@@ -207,69 +366,40 @@ export class UserSubscriptionManager implements SubscriptionManager {}}- return {- price,- coupon,- };+ return coupon;}async saveInvoice(knownInvoice: KnownStripeInvoice) {const { userId, lookupKey, stripeInvoice } = knownInvoice;- const status = stripeInvoice.status ?? 'void';- let error: string | boolean | null = null;-- if (status !== 'paid') {- if (stripeInvoice.last_finalization_error) {- error = stripeInvoice.last_finalization_error.message ?? true;- } else if (- stripeInvoice.attempt_count > 1 &&- stripeInvoice.payment_intent- ) {- const paymentIntent =- typeof stripeInvoice.payment_intent === 'string'- ? await this.stripe.paymentIntents.retrieve(- stripeInvoice.payment_intent- )- : stripeInvoice.payment_intent;-- if (paymentIntent.last_payment_error) {- error = paymentIntent.last_payment_error.message ?? true;- }- }- }-- // fallback to generic error message- if (error === true) {- error = 'Payment Error. Please contact support.';- }+ const invoiceData = await this.transformInvoice(knownInvoice);- const invoice = this.db.userInvoice.upsert({+ // @deprecated backward compatibility+ await this.db.deprecatedUserInvoice.upsert({where: {stripeInvoiceId: stripeInvoice.id,},- update: {- status,- link: stripeInvoice.hosted_invoice_url,- amount: stripeInvoice.total,- currency: stripeInvoice.currency,- lastPaymentError: error,- },+ update: omit(invoiceData, 'stripeInvoiceId'),create: {userId,+ ...invoiceData,+ },+ });++ const invoice = this.db.invoice.upsert({+ where: {stripeInvoiceId: stripeInvoice.id,- status,- link: stripeInvoice.hosted_invoice_url,- reason: stripeInvoice.billing_reason,- amount: stripeInvoice.total,- currency: stripeInvoice.currency,- lastPaymentError: error,+ },+ update: omit(invoiceData, 'stripeInvoiceId'),+ create: {+ targetId: userId,+ ...invoiceData,},});// onetime and lifetime subscription is a special "subscription" that doesn't get involved with stripe subscription system// we track the deals by invoice only.- if (status === 'paid') {+ if (stripeInvoice.status === 'paid') {if (lookupKey.recurring === SubscriptionRecurring.Lifetime) {await this.saveLifetimeSubscription(knownInvoice);} else if (lookupKey.variant === SubscriptionVariant.Onetime) {@@ -282,45 +412,49 @@ export class UserSubscriptionManager implements SubscriptionManager {async saveLifetimeSubscription(knownInvoice: KnownStripeInvoice- ): Promise<UserSubscription> {+ ): Promise<Subscription> {// cancel previous non-lifetime subscription- const prevSubscription = await this.db.userSubscription.findUnique({+ const prevSubscription = await this.db.subscription.findUnique({where: {- userId_plan: {- userId: knownInvoice.userId,+ targetId_plan: {+ targetId: knownInvoice.userId,plan: SubscriptionPlan.Pro,},},});- let subscription: UserSubscription;- if (prevSubscription && prevSubscription.stripeSubscriptionId) {- subscription = await this.db.userSubscription.update({- where: {- id: prevSubscription.id,- },- data: {- stripeScheduleId: null,- stripeSubscriptionId: null,- plan: knownInvoice.lookupKey.plan,- recurring: SubscriptionRecurring.Lifetime,- start: new Date(),- end: null,- status: SubscriptionStatus.Active,- nextBillAt: null,- },- });-- await this.stripe.subscriptions.cancel(- prevSubscription.stripeSubscriptionId,- {- prorate: true,- }- );+ let subscription: Subscription;+ if (prevSubscription) {+ if (prevSubscription.stripeSubscriptionId) {+ subscription = await this.db.subscription.update({+ where: {+ id: prevSubscription.id,+ },+ data: {+ stripeScheduleId: null,+ stripeSubscriptionId: null,+ plan: knownInvoice.lookupKey.plan,+ recurring: SubscriptionRecurring.Lifetime,+ start: new Date(),+ end: null,+ status: SubscriptionStatus.Active,+ nextBillAt: null,+ },+ });++ await this.stripe.subscriptions.cancel(+ prevSubscription.stripeSubscriptionId,+ {+ prorate: true,+ }+ );+ } else {+ subscription = prevSubscription;+ }} else {- subscription = await this.db.userSubscription.create({+ subscription = await this.db.subscription.create({data: {- userId: knownInvoice.userId,+ targetId: knownInvoice.userId,stripeSubscriptionId: null,plan: knownInvoice.lookupKey.plan,recurring: SubscriptionRecurring.Lifetime,@@ -343,12 +477,13 @@ export class UserSubscriptionManager implements SubscriptionManager {async saveOnetimePaymentSubscription(knownInvoice: KnownStripeInvoice- ): Promise<UserSubscription> {+ ): Promise<Subscription> {+ // TODO(@forehalo): identify whether the invoice has already been redeemed.const { userId, lookupKey } = knownInvoice;- const existingSubscription = await this.db.userSubscription.findUnique({+ const existingSubscription = await this.db.subscription.findUnique({where: {- userId_plan: {- userId,+ targetId_plan: {+ targetId: userId,plan: lookupKey.plan,},},@@ -362,7 +497,7 @@ export class UserSubscriptionManager implements SubscriptionManager {60 *1000;- let subscription: UserSubscription;+ let subscription: Subscription;// extends the subscription time if existsif (existingSubscription) {@@ -385,16 +520,16 @@ export class UserSubscriptionManager implements SubscriptionManager {),};- subscription = await this.db.userSubscription.update({+ subscription = await this.db.subscription.update({where: {id: existingSubscription.id,},data: period,});} else {- subscription = await this.db.userSubscription.create({+ subscription = await this.db.subscription.create({data: {- userId,+ targetId: userId,stripeSubscriptionId: null,...lookupKey,start: new Date(),diff --git a/packages/backend/server/src/plugins/payment/manager/workspace.ts b/packages/backend/server/src/plugins/payment/manager/workspace.tsnew file mode 100644index 0000000000..5eba7ae036--- /dev/null+++ b/packages/backend/server/src/plugins/payment/manager/workspace.ts@@ -0,0 +1,305 @@+import { Injectable } from '@nestjs/common';+import { PrismaClient, UserStripeCustomer } from '@prisma/client';+import { omit, pick } from 'lodash-es';+import Stripe from 'stripe';+import { z } from 'zod';++import {+ EventEmitter,+ type EventPayload,+ OnEvent,+ SubscriptionAlreadyExists,+ URLHelper,+} from '../../../fundamentals';+import {+ KnownStripeInvoice,+ KnownStripePrice,+ KnownStripeSubscription,+ retriveLookupKeyFromStripeSubscription,+ SubscriptionPlan,+ SubscriptionRecurring,+ SubscriptionStatus,+} from '../types';+import {+ CheckoutParams,+ Invoice,+ Subscription,+ SubscriptionManager,+} from './common';++export const WorkspaceSubscriptionIdentity = z.object({+ plan: z.literal(SubscriptionPlan.Team),+ workspaceId: z.string(),+});++export const WorkspaceSubscriptionCheckoutArgs = z.object({+ plan: z.literal(SubscriptionPlan.Team),+ workspaceId: z.string(),+ user: z.object({+ id: z.string(),+ email: z.string(),+ }),+});++@Injectable()+export class WorkspaceSubscriptionManager extends SubscriptionManager {+ constructor(+ stripe: Stripe,+ db: PrismaClient,+ private readonly url: URLHelper,+ private readonly event: EventEmitter+ ) {+ super(stripe, db);+ }++ filterPrices(+ prices: KnownStripePrice[],+ _customer?: UserStripeCustomer+ ): KnownStripePrice[] {+ return prices.filter(+ price => price.lookupKey.plan === SubscriptionPlan.Team+ );+ }++ async checkout(+ { price }: KnownStripePrice,+ params: z.infer<typeof CheckoutParams>,+ args: z.infer<typeof WorkspaceSubscriptionCheckoutArgs>+ ) {+ const subscription = await this.getSubscription({+ plan: SubscriptionPlan.Team,+ workspaceId: args.workspaceId,+ });++ if (subscription) {+ throw new SubscriptionAlreadyExists({ plan: SubscriptionPlan.Team });+ }++ const customer = await this.getOrCreateCustomer(args.user.id);++ const discounts = await (async () => {+ if (params.coupon) {+ const couponId = await this.getCouponFromPromotionCode(+ params.coupon,+ customer+ );+ if (couponId) {+ return { discounts: [{ coupon: couponId }] };+ }+ }++ return { allow_promotion_codes: true };+ })();++ const count = await this.db.workspaceUserPermission.count({+ where: {+ workspaceId: args.workspaceId,+ // @TODO(darksky): replace with [status: WorkspaceUserPermissionStatus.Accepted]+ accepted: true,+ },+ });++ return this.stripe.checkout.sessions.create({+ line_items: [+ {+ price: price.id,+ quantity: count,+ },+ ],+ tax_id_collection: {+ enabled: true,+ },++ ...discounts,+ mode: 'subscription',+ success_url: this.url.link(params.successCallbackLink),+ customer: customer.stripeCustomerId,+ subscription_data: {+ metadata: {+ workspaceId: args.workspaceId,+ },+ },+ });+ }++ async saveStripeSubscription(subscription: KnownStripeSubscription) {+ const { lookupKey, quantity, stripeSubscription } = subscription;++ const workspaceId = stripeSubscription.metadata.workspaceId;++ if (!workspaceId) {+ throw new Error(+ 'Workspace ID is required in workspace subscription metadata'+ );+ }++ this.event.emit('workspace.subscription.activated', {+ workspaceId,+ plan: lookupKey.plan,+ recurring: lookupKey.recurring,+ quantity,+ });++ const subscriptionData = this.transformSubscription(subscription);++ return this.db.subscription.upsert({+ where: {+ stripeSubscriptionId: stripeSubscription.id,+ },+ update: {+ quantity,+ ...pick(subscriptionData, [+ 'status',+ 'stripeScheduleId',+ 'nextBillAt',+ 'canceledAt',+ ]),+ },+ create: {+ targetId: workspaceId,+ quantity,+ ...subscriptionData,+ },+ });+ }++ async deleteStripeSubscription({+ lookupKey,+ stripeSubscription,+ }: KnownStripeSubscription) {+ const workspaceId = stripeSubscription.metadata.workspaceId;++ if (!workspaceId) {+ throw new Error(+ 'Workspace ID is required in workspace subscription metadata'+ );+ }++ const deleted = await this.db.subscription.deleteMany({+ where: { stripeSubscriptionId: stripeSubscription.id },+ });++ if (deleted.count > 0) {+ this.event.emit('workspace.subscription.canceled', {+ workspaceId,+ plan: lookupKey.plan,+ recurring: lookupKey.recurring,+ });+ }+ }++ getSubscription(identity: z.infer<typeof WorkspaceSubscriptionIdentity>) {+ return this.db.subscription.findFirst({+ where: {+ targetId: identity.workspaceId,+ status: {+ in: [SubscriptionStatus.Active, SubscriptionStatus.Trialing],+ },+ },+ });+ }++ async cancelSubscription(subscription: Subscription) {+ return await this.db.subscription.update({+ where: {+ // @ts-expect-error checked outside+ stripeSubscriptionId: subscription.stripeSubscriptionId,+ },+ data: {+ canceledAt: new Date(),+ nextBillAt: null,+ },+ });+ }++ resumeSubscription(subscription: Subscription): Promise<Subscription> {+ return this.db.subscription.update({+ where: {+ // @ts-expect-error checked outside+ stripeSubscriptionId: subscription.stripeSubscriptionId,+ },+ data: {+ canceledAt: null,+ nextBillAt: subscription.end,+ },+ });+ }++ updateSubscriptionRecurring(+ subscription: Subscription,+ recurring: SubscriptionRecurring+ ): Promise<Subscription> {+ return this.db.subscription.update({+ where: {+ // @ts-expect-error checked outside+ stripeSubscriptionId: subscription.stripeSubscriptionId,+ },+ data: { recurring },+ });+ }++ async saveInvoice(knownInvoice: KnownStripeInvoice): Promise<Invoice> {+ const { metadata, stripeInvoice } = knownInvoice;++ const workspaceId = metadata.workspaceId;++ if (!workspaceId) {+ throw new Error('Workspace ID is required in workspace invoice metadata');+ }++ const invoiceData = await this.transformInvoice(knownInvoice);++ return this.db.invoice.upsert({+ where: {+ stripeInvoiceId: stripeInvoice.id,+ },+ update: omit(invoiceData, 'stripeInvoiceId'),+ create: {+ targetId: workspaceId,+ ...invoiceData,+ },+ });+ }++ @OnEvent('workspace.members.updated')+ async onMembersUpdated({+ workspaceId,+ count,+ }: EventPayload<'workspace.members.updated'>) {+ const subscription = await this.getSubscription({+ plan: SubscriptionPlan.Team,+ workspaceId,+ });++ if (!subscription || !subscription.stripeSubscriptionId) {+ return;+ }+ const stripeSubscription = await this.stripe.subscriptions.retrieve(+ subscription.stripeSubscriptionId+ );++ const lookupKey =+ retriveLookupKeyFromStripeSubscription(stripeSubscription);++ await this.stripe.subscriptions.update(stripeSubscription.id, {+ items: [+ {+ id: stripeSubscription.items.data[0].id,+ quantity: count,+ },+ ],+ payment_behavior: 'pending_if_incomplete',+ proration_behavior:+ lookupKey?.recurring === SubscriptionRecurring.Yearly+ ? 'always_invoice'+ : 'none',+ });++ if (subscription.stripeScheduleId) {+ const schedule = await this.scheduleManager.fromSchedule(+ subscription.stripeScheduleId+ );+ await schedule.updateQuantity(count);+ }+ }+}diff --git a/packages/backend/server/src/plugins/payment/resolver.ts b/packages/backend/server/src/plugins/payment/resolver.tsindex 6a2cabecef..d71399fba3 100644--- a/packages/backend/server/src/plugins/payment/resolver.ts+++ b/packages/backend/server/src/plugins/payment/resolver.ts@@ -12,15 +12,23 @@ import {ResolveField,Resolver,} from '@nestjs/graphql';-import type { User, UserSubscription } from '@prisma/client';+import type { User } from '@prisma/client';import { PrismaClient } from '@prisma/client';+import { GraphQLJSONObject } from 'graphql-scalars';import { groupBy } from 'lodash-es';+import { z } from 'zod';import { CurrentUser, Public } from '../../core/auth';+import { Permission, PermissionService } from '../../core/permission';import { UserType } from '../../core/user';-import { AccessDenied, FailedToCheckout, URLHelper } from '../../fundamentals';-import { Invoice, Subscription } from './manager';-import { SubscriptionService } from './service';+import { WorkspaceType } from '../../core/workspaces';+import {+ AccessDenied,+ FailedToCheckout,+ WorkspaceIdRequiredToUpdateTeamSubscription,+} from '../../fundamentals';+import { Invoice, Subscription, WorkspaceSubscriptionManager } from './manager';+import { CheckoutParams, SubscriptionService } from './service';import {InvoiceStatus,SubscriptionPlan,@@ -57,7 +65,7 @@ class SubscriptionPrice {}@ObjectType()-export class SubscriptionType implements Subscription {+export class SubscriptionType implements Partial<Subscription> {@Field(() => SubscriptionPlan, {description:"The 'Free' plan just exists to be a placeholder and for the type convenience of frontend.\nThere won't actually be a subscription with plan 'Free'",@@ -107,7 +115,7 @@ export class SubscriptionType implements Subscription {}@ObjectType()-export class InvoiceType implements Invoice {+export class InvoiceType implements Partial<Invoice> {@Field()currency!: string;@@ -138,7 +146,7 @@ export class InvoiceType implements Invoice {nullable: true,deprecationReason: 'removed',})- stripeInvoiceId!: string | null;+ stripeInvoiceId?: string;@Field(() => SubscriptionPlan, {nullable: true,@@ -154,7 +162,7 @@ export class InvoiceType implements Invoice {}@InputType()-class CreateCheckoutSessionInput {+class CreateCheckoutSessionInput implements z.infer<typeof CheckoutParams> {@Field(() => SubscriptionRecurring, {nullable: true,defaultValue: SubscriptionRecurring.Yearly,@@ -170,7 +178,7 @@ class CreateCheckoutSessionInput {@Field(() => SubscriptionVariant, {nullable: true,})- variant?: SubscriptionVariant;+ variant!: SubscriptionVariant | null;@Field(() => String, { nullable: true })coupon!: string | null;@@ -180,17 +188,17 @@ class CreateCheckoutSessionInput {@Field(() => String, {nullable: true,- deprecationReason: 'use header `Idempotency-Key`',+ deprecationReason: 'not required anymore',})idempotencyKey?: string;++ @Field(() => GraphQLJSONObject, { nullable: true })+ args!: { workspaceId?: string };}@Resolver(() => SubscriptionType)export class SubscriptionResolver {- constructor(- private readonly service: SubscriptionService,- private readonly url: URLHelper- ) {}+ constructor(private readonly service: SubscriptionService) {}@Public()@Query(() => [SubscriptionPrice])@@ -232,7 +240,11 @@ export class SubscriptionResolver {}// extend it when new plans are added- const fixedPlans = [SubscriptionPlan.Pro, SubscriptionPlan.AI];+ const fixedPlans = [+ SubscriptionPlan.Pro,+ SubscriptionPlan.AI,+ SubscriptionPlan.Team,+ ];return fixedPlans.reduce((prices, plan) => {const price = findPrice(plan);@@ -255,26 +267,19 @@ export class SubscriptionResolver {async createCheckoutSession(@CurrentUser() user: CurrentUser,@Args({ name: 'input', type: () => CreateCheckoutSessionInput })- input: CreateCheckoutSessionInput,- @Headers('idempotency-key') idempotencyKey?: string+ input: CreateCheckoutSessionInput) {- const session = await this.service.checkout({+ const session = await this.service.checkout(input, {+ plan: input.plan as any,user,- lookupKey: {- plan: input.plan,- recurring: input.recurring,- variant: input.variant,- },- promotionCode: input.coupon,- redirectUrl: this.url.link(input.successCallbackLink),- idempotencyKey,+ workspaceId: input.args?.workspaceId,});if (!session.url) {throw new FailedToCheckout();}- return session.url;+ return session;}@Mutation(() => String, {@@ -294,6 +299,8 @@ export class SubscriptionResolver {defaultValue: SubscriptionPlan.Pro,})plan: SubscriptionPlan,+ @Args({ name: 'workspaceId', type: () => String, nullable: true })+ workspaceId: string | null,@Headers('idempotency-key') idempotencyKey?: string,@Args('idempotencyKey', {type: () => String,@@ -302,7 +309,25 @@ export class SubscriptionResolver {})_?: string) {- return this.service.cancelSubscription(user.id, plan, idempotencyKey);+ if (plan === SubscriptionPlan.Team) {+ if (!workspaceId) {+ throw new WorkspaceIdRequiredToUpdateTeamSubscription();+ }++ return this.service.cancelSubscription(+ { workspaceId, plan },+ idempotencyKey+ );+ }++ return this.service.cancelSubscription(+ {+ targetId: user.id,+ // @ts-expect-error exam inside+ plan,+ },+ idempotencyKey+ );}@Mutation(() => SubscriptionType)@@ -315,6 +340,8 @@ export class SubscriptionResolver {defaultValue: SubscriptionPlan.Pro,})plan: SubscriptionPlan,+ @Args({ name: 'workspaceId', type: () => String, nullable: true })+ workspaceId: string | null,@Headers('idempotency-key') idempotencyKey?: string,@Args('idempotencyKey', {type: () => String,@@ -323,14 +350,30 @@ export class SubscriptionResolver {})_?: string) {- return this.service.resumeSubscription(user.id, plan, idempotencyKey);+ if (plan === SubscriptionPlan.Team) {+ if (!workspaceId) {+ throw new WorkspaceIdRequiredToUpdateTeamSubscription();+ }++ return this.service.resumeSubscription(+ { workspaceId, plan },+ idempotencyKey+ );+ }++ return this.service.resumeSubscription(+ {+ targetId: user.id,+ // @ts-expect-error exam inside+ plan,+ },+ idempotencyKey+ );}@Mutation(() => SubscriptionType)async updateSubscriptionRecurring(@CurrentUser() user: CurrentUser,- @Args({ name: 'recurring', type: () => SubscriptionRecurring })- recurring: SubscriptionRecurring,@Args({name: 'plan',type: () => SubscriptionPlan,@@ -338,6 +381,10 @@ export class SubscriptionResolver {defaultValue: SubscriptionPlan.Pro,})plan: SubscriptionPlan,+ @Args({ name: 'workspaceId', type: () => String, nullable: true })+ workspaceId: string | null,+ @Args({ name: 'recurring', type: () => SubscriptionRecurring })+ recurring: SubscriptionRecurring,@Headers('idempotency-key') idempotencyKey?: string,@Args('idempotencyKey', {type: () => String,@@ -346,9 +393,24 @@ export class SubscriptionResolver {})_?: string) {+ if (plan === SubscriptionPlan.Team) {+ if (!workspaceId) {+ throw new WorkspaceIdRequiredToUpdateTeamSubscription();+ }++ return this.service.updateSubscriptionRecurring(+ { workspaceId, plan },+ recurring,+ idempotencyKey+ );+ }+return this.service.updateSubscriptionRecurring(- user.id,- plan,+ {+ userId: user.id,+ // @ts-expect-error exam inside+ plan,+ },recurring,idempotencyKey);@@ -363,14 +425,14 @@ export class UserSubscriptionResolver {async subscriptions(@CurrentUser() me: User,@Parent() user: User- ): Promise<UserSubscription[]> {+ ): Promise<Subscription[]> {if (me.id !== user.id) {throw new AccessDenied();}- const subscriptions = await this.db.userSubscription.findMany({+ const subscriptions = await this.db.subscription.findMany({where: {- userId: user.id,+ targetId: user.id,status: SubscriptionStatus.Active,},});@@ -389,6 +451,16 @@ export class UserSubscriptionResolver {return subscriptions;}+ @ResolveField(() => Int, {+ name: 'invoiceCount',+ description: 'Get user invoice count',+ })+ async invoiceCount(@CurrentUser() user: CurrentUser) {+ return this.db.invoice.count({+ where: { targetId: user.id },+ });+ }+@ResolveField(() => [InvoiceType])async invoices(@CurrentUser() me: User,@@ -401,14 +473,72 @@ export class UserSubscriptionResolver {throw new AccessDenied();}- return this.db.userInvoice.findMany({+ return this.db.invoice.findMany({where: {- userId: user.id,+ targetId: user.id,+ },+ take,+ skip,+ orderBy: {+ createdAt: 'desc',+ },+ });+ }+}++@Resolver(() => WorkspaceType)+export class WorkspaceSubscriptionResolver {+ constructor(+ private readonly service: WorkspaceSubscriptionManager,+ private readonly db: PrismaClient,+ private readonly permission: PermissionService+ ) {}++ @ResolveField(() => SubscriptionType, {+ nullable: true,+ description: 'The team subscription of the workspace, if exists.',+ })+ async subscription(@Parent() workspace: WorkspaceType) {+ return this.service.getSubscription({+ plan: SubscriptionPlan.Team,+ workspaceId: workspace.id,+ });+ }++ @ResolveField(() => Int, {+ name: 'invoiceCount',+ description: 'Get user invoice count',+ })+ async invoiceCount(+ @CurrentUser() me: CurrentUser,+ @Parent() workspace: WorkspaceType+ ) {+ await this.permission.checkWorkspace(workspace.id, me.id, Permission.Owner);+ return this.db.invoice.count({+ where: {+ targetId: workspace.id,+ },+ });+ }++ @ResolveField(() => [InvoiceType])+ async invoices(+ @CurrentUser() me: CurrentUser,+ @Parent() workspace: WorkspaceType,+ @Args('take', { type: () => Int, nullable: true, defaultValue: 8 })+ take: number,+ @Args('skip', { type: () => Int, nullable: true }) skip?: number+ ) {+ await this.permission.checkWorkspace(workspace.id, me.id, Permission.Owner);++ return this.db.invoice.findMany({+ where: {+ targetId: workspace.id,},take,skip,orderBy: {- id: 'desc',+ createdAt: 'desc',},});}diff --git a/packages/backend/server/src/plugins/payment/schedule.ts b/packages/backend/server/src/plugins/payment/schedule.tsindex f0714cf1c5..b4c2abb35f 100644--- a/packages/backend/server/src/plugins/payment/schedule.ts+++ b/packages/backend/server/src/plugins/payment/schedule.ts@@ -101,7 +101,7 @@ export class ScheduleManager {items: [{price: this.currentPhase.items[0].price as string,- quantity: 1,+ quantity: this.currentPhase.items[0].quantity,},],coupon: (this.currentPhase.coupon as string | null) ?? undefined,@@ -143,10 +143,9 @@ export class ScheduleManager {items: [{price: this.currentPhase.items[0].price as string,- quantity: 1,+ quantity: this.currentPhase.items[0].quantity,},],- coupon: (this.currentPhase.coupon as string | null) ?? undefined,start_date: this.currentPhase.start_date,end_date: this.currentPhase.end_date,metadata: {@@ -161,7 +160,7 @@ export class ScheduleManager {items: [{price: this.currentPhase.metadata.next_price,- quantity: 1,+ quantity: this.currentPhase.items[0].quantity,},],coupon: this.currentPhase.metadata.next_coupon || undefined,@@ -212,6 +211,7 @@ export class ScheduleManager {items: [{price: this.currentPhase.items[0].price as string,+ quantity: this.currentPhase.items[0].quantity,},],start_date: this.currentPhase.start_date,@@ -221,6 +221,7 @@ export class ScheduleManager {items: [{price: price,+ quantity: this.currentPhase.items[0].quantity,},],},@@ -230,4 +231,31 @@ export class ScheduleManager {);}}++ async updateQuantity(quantity: number, idempotencyKey?: string) {+ if (!this._schedule) {+ throw new Error('No schedule');+ }++ if (!this.isActive || !this.currentPhase) {+ throw new Error('Unexpected subscription schedule status');+ }++ await this.stripe.subscriptionSchedules.update(+ this._schedule.id,+ {+ phases: this._schedule.phases.map(phase => ({+ items: [+ {+ price: phase.items[0].price as string,+ quantity,+ },+ ],+ start_date: phase.start_date,+ end_date: phase.end_date,+ })),+ },+ { idempotencyKey }+ );+ }}diff --git a/packages/backend/server/src/plugins/payment/service.ts b/packages/backend/server/src/plugins/payment/service.tsindex 2de5f031d8..facdb19df1 100644--- a/packages/backend/server/src/plugins/payment/service.ts+++ b/packages/backend/server/src/plugins/payment/service.ts@@ -1,12 +1,8 @@import { Injectable, Logger } from '@nestjs/common';-import type {- User,- UserInvoice,- UserStripeCustomer,- UserSubscription,-} from '@prisma/client';+import type { User, UserStripeCustomer } from '@prisma/client';import { PrismaClient } from '@prisma/client';import Stripe from 'stripe';+import { z } from 'zod';import { CurrentUser } from '../../core/auth';import { FeatureManagementService } from '../../core/features';@@ -17,30 +13,56 @@ import {Config,CustomerPortalCreateFailed,InternalServerError,+ InvalidCheckoutParameters,+ InvalidSubscriptionParameters,OnEvent,SameSubscriptionRecurring,- SubscriptionAlreadyExists,SubscriptionExpired,SubscriptionHasBeenCanceled,+ SubscriptionHasNotBeenCanceled,SubscriptionNotExists,SubscriptionPlanNotFound,+ UnsupportedSubscriptionPlan,UserNotFound,} from '../../fundamentals';-import { UserSubscriptionManager } from './manager';+import {+ CheckoutParams,+ Invoice,+ Subscription,+ SubscriptionManager,+ UserSubscriptionCheckoutArgs,+ UserSubscriptionIdentity,+ UserSubscriptionManager,+ WorkspaceSubscriptionCheckoutArgs,+ WorkspaceSubscriptionIdentity,+ WorkspaceSubscriptionManager,+} from './manager';import { ScheduleManager } from './schedule';import {encodeLookupKey,KnownStripeInvoice,KnownStripePrice,+ KnownStripeSubscription,LookupKey,retriveLookupKeyFromStripePrice,retriveLookupKeyFromStripeSubscription,SubscriptionPlan,SubscriptionRecurring,SubscriptionStatus,- SubscriptionVariant,} from './types';+export const CheckoutExtraArgs = z.union([+ UserSubscriptionCheckoutArgs,+ WorkspaceSubscriptionCheckoutArgs,+]);++export const SubscriptionIdentity = z.union([+ UserSubscriptionIdentity,+ WorkspaceSubscriptionIdentity,+]);++export { CheckoutParams };+@Injectable()export class SubscriptionService {private readonly logger = new Logger(SubscriptionService.name);@@ -52,143 +74,86 @@ export class SubscriptionService {private readonly db: PrismaClient,private readonly feature: FeatureManagementService,private readonly user: UserService,- private readonly userManager: UserSubscriptionManager+ private readonly userManager: UserSubscriptionManager,+ private readonly workspaceManager: WorkspaceSubscriptionManager) {}- async listPrices(user?: CurrentUser): Promise<KnownStripePrice[]> {- const customer = user ? await this.getOrCreateCustomer(user) : undefined;+ private select(plan: SubscriptionPlan): SubscriptionManager {+ switch (plan) {+ case SubscriptionPlan.Team:+ return this.workspaceManager;+ case SubscriptionPlan.Pro:+ case SubscriptionPlan.AI:+ return this.userManager;+ default:+ throw new UnsupportedSubscriptionPlan({ plan });+ }+ }- // TODO(@forehalo): cache- const prices = await this.stripe.prices.list({- active: true,- limit: 100,- });+ async listPrices(user?: CurrentUser): Promise<KnownStripePrice[]> {+ const prices = await this.listStripePrices();- return this.userManager.filterPrices(- prices.data- .map(price => this.parseStripePrice(price))- .filter(Boolean) as KnownStripePrice[],- customer- );+ const customer = user+ ? await this.getOrCreateCustomer({+ userId: user.id,+ userEmail: user.email,+ })+ : undefined;++ return [+ ...(await this.userManager.filterPrices(prices, customer)),+ ...this.workspaceManager.filterPrices(prices, customer),+ ];}- async checkout({- user,- lookupKey,- promotionCode,- redirectUrl,- idempotencyKey,- }: {- user: CurrentUser;- lookupKey: LookupKey;- promotionCode?: string | null;- redirectUrl: string;- idempotencyKey?: string;- }) {+ async checkout(+ params: z.infer<typeof CheckoutParams>,+ args: z.infer<typeof CheckoutExtraArgs>+ ) {+ const { plan, recurring, variant } = params;+if (this.config.deploy &&this.config.affine.canary &&- !this.feature.isStaff(user.email)+ !this.feature.isStaff(args.user.email)) {throw new ActionForbidden();}- const currentSubscription = await this.userManager.getSubscription(- user.id,- lookupKey.plan- );-- if (- currentSubscription &&- // do not allow to re-subscribe unless- !(- /* current subscription is a onetime subscription and so as the one that's checking out */- (- (currentSubscription.variant === SubscriptionVariant.Onetime &&- lookupKey.variant === SubscriptionVariant.Onetime) ||- /* current subscription is normal subscription and is checking-out a lifetime subscription */- (currentSubscription.recurring !== SubscriptionRecurring.Lifetime &&- currentSubscription.variant !== SubscriptionVariant.Onetime &&- lookupKey.recurring === SubscriptionRecurring.Lifetime)- )- )- ) {- throw new SubscriptionAlreadyExists({ plan: lookupKey.plan });- }-- const price = await this.getPrice(lookupKey);- const customer = await this.getOrCreateCustomer(user);-- const priceAndAutoCoupon = price- ? await this.userManager.validatePrice(price, customer)- : null;+ const price = await this.getPrice({+ plan,+ recurring,+ variant: variant ?? null,+ });- if (!priceAndAutoCoupon) {+ if (!price) {throw new SubscriptionPlanNotFound({- plan: lookupKey.plan,- recurring: lookupKey.recurring,+ plan,+ recurring,});}- let discounts: Stripe.Checkout.SessionCreateParams['discounts'] = [];+ const manager = this.select(plan);+ const result = CheckoutExtraArgs.safeParse(args);- if (priceAndAutoCoupon.coupon) {- discounts = [{ coupon: priceAndAutoCoupon.coupon }];- } else if (promotionCode) {- const coupon = await this.getCouponFromPromotionCode(- promotionCode,- customer- );- if (coupon) {- discounts = [{ coupon }];- }+ if (!result.success) {+ throw new InvalidCheckoutParameters();}- return await this.stripe.checkout.sessions.create(- {- line_items: [- {- price: priceAndAutoCoupon.price.price.id,- quantity: 1,- },- ],- tax_id_collection: {- enabled: true,- },- // discount- ...(discounts.length ? { discounts } : { allow_promotion_codes: true }),- // mode: 'subscription' or 'payment' for lifetime and onetime payment- ...(lookupKey.recurring === SubscriptionRecurring.Lifetime ||- lookupKey.variant === SubscriptionVariant.Onetime- ? {- mode: 'payment',- invoice_creation: {- enabled: true,- },- }- : {- mode: 'subscription',- }),- success_url: redirectUrl,- customer: customer.stripeCustomerId,- customer_update: {- address: 'auto',- name: 'auto',- },- },- { idempotencyKey }- );+ return manager.checkout(price, params, args);}async cancelSubscription(- userId: string,- plan: SubscriptionPlan,+ identity: z.infer<typeof SubscriptionIdentity>,idempotencyKey?: string- ): Promise<UserSubscription> {- const subscription = await this.userManager.getSubscription(userId, plan);+ ): Promise<Subscription> {+ this.assertSubscriptionIdentity(identity);++ const manager = this.select(identity.plan);+ const subscription = await manager.getSubscription(identity);if (!subscription) {- throw new SubscriptionNotExists({ plan });+ throw new SubscriptionNotExists({ plan: identity.plan });}if (!subscription.stripeSubscriptionId) {@@ -202,7 +167,7 @@ export class SubscriptionService {}// update the subscription in db optimistically- const newSubscription = this.userManager.cancelSubscription(subscription);+ const newSubscription = manager.cancelSubscription(subscription);// should release the schedule firstif (subscription.stripeScheduleId) {@@ -224,18 +189,21 @@ export class SubscriptionService {}async resumeSubscription(- userId: string,- plan: SubscriptionPlan,+ identity: z.infer<typeof SubscriptionIdentity>,idempotencyKey?: string- ): Promise<UserSubscription> {- const subscription = await this.userManager.getSubscription(userId, plan);+ ): Promise<Subscription> {+ this.assertSubscriptionIdentity(identity);++ const manager = this.select(identity.plan);++ const subscription = await manager.getSubscription(identity);if (!subscription) {- throw new SubscriptionNotExists({ plan });+ throw new SubscriptionNotExists({ plan: identity.plan });}if (!subscription.canceledAt) {- throw new SubscriptionHasBeenCanceled();+ throw new SubscriptionHasNotBeenCanceled();}if (!subscription.stripeSubscriptionId || !subscription.end) {@@ -249,8 +217,7 @@ export class SubscriptionService {}// update the subscription in db optimistically- const newSubscription =- await this.userManager.resumeSubscription(subscription);+ const newSubscription = await manager.resumeSubscription(subscription);if (subscription.stripeScheduleId) {const manager = await this.scheduleManager.fromSchedule(@@ -269,15 +236,17 @@ export class SubscriptionService {}async updateSubscriptionRecurring(- userId: string,- plan: SubscriptionPlan,+ identity: z.infer<typeof SubscriptionIdentity>,recurring: SubscriptionRecurring,idempotencyKey?: string- ): Promise<UserSubscription> {- const subscription = await this.userManager.getSubscription(userId, plan);+ ): Promise<Subscription> {+ this.assertSubscriptionIdentity(identity);++ const manager = this.select(identity.plan);+ const subscription = await manager.getSubscription(identity);if (!subscription) {- throw new SubscriptionNotExists({ plan });+ throw new SubscriptionNotExists({ plan: identity.plan });}if (!subscription.stripeSubscriptionId) {@@ -293,25 +262,29 @@ export class SubscriptionService {}const price = await this.getPrice({- plan,+ plan: identity.plan,recurring,+ variant: null,});if (!price) {- throw new SubscriptionPlanNotFound({ plan, recurring });+ throw new SubscriptionPlanNotFound({+ plan: identity.plan,+ recurring,+ });}// update the subscription in db optimistically- const newSubscription = this.userManager.updateSubscriptionRecurring(+ const newSubscription = manager.updateSubscriptionRecurring(subscription,recurring);- const manager = await this.scheduleManager.fromSubscription(+ const scheduleManager = await this.scheduleManager.fromSubscription(subscription.stripeSubscriptionId);- await manager.update(price.price.id, idempotencyKey);+ await scheduleManager.update(price.price.id, idempotencyKey);return newSubscription;}@@ -339,14 +312,14 @@ export class SubscriptionService {}}- async saveStripeInvoice(stripeInvoice: Stripe.Invoice): Promise<UserInvoice> {+ async saveStripeInvoice(stripeInvoice: Stripe.Invoice): Promise<Invoice> {const knownInvoice = await this.parseStripeInvoice(stripeInvoice);if (!knownInvoice) {throw new InternalServerError('Failed to parse stripe invoice.');}- return this.userManager.saveInvoice(knownInvoice);+ return this.select(knownInvoice.lookupKey.plan).saveInvoice(knownInvoice);}async saveStripeSubscription(subscription: Stripe.Subscription) {@@ -360,10 +333,12 @@ export class SubscriptionService {subscription.status === SubscriptionStatus.Active ||subscription.status === SubscriptionStatus.Trialing;+ const manager = this.select(knownSubscription.lookupKey.plan);+if (!isPlanActive) {- await this.userManager.deleteSubscription(knownSubscription);+ await manager.deleteStripeSubscription(knownSubscription);} else {- await this.userManager.saveSubscription(knownSubscription);+ await manager.saveStripeSubscription(knownSubscription);}}@@ -374,19 +349,26 @@ export class SubscriptionService {throw new InternalServerError('Failed to parse stripe subscription.');}- await this.userManager.deleteSubscription(knownSubscription);+ const manager = this.select(knownSubscription.lookupKey.plan);+ await manager.deleteStripeSubscription(knownSubscription);}- async getOrCreateCustomer(user: CurrentUser): Promise<UserStripeCustomer> {+ async getOrCreateCustomer({+ userId,+ userEmail,+ }: {+ userId: string;+ userEmail: string;+ }): Promise<UserStripeCustomer> {let customer = await this.db.userStripeCustomer.findUnique({where: {- userId: user.id,+ userId,},});if (!customer) {const stripeCustomersList = await this.stripe.customers.list({- email: user.email,+ email: userEmail,limit: 1,});@@ -395,13 +377,13 @@ export class SubscriptionService {stripeCustomer = stripeCustomersList.data[0];} else {stripeCustomer = await this.stripe.customers.create({- email: user.email,+ email: userEmail,});}customer = await this.db.userStripeCustomer.create({data: {- userId: user.id,+ userId,stripeCustomerId: stripeCustomer.id,},});@@ -467,6 +449,17 @@ export class SubscriptionService {return user.id;}+ private async listStripePrices(): Promise<KnownStripePrice[]> {+ const prices = await this.stripe.prices.list({+ active: true,+ limit: 100,+ });++ return prices.data+ .map(price => this.parseStripePrice(price))+ .filter(Boolean) as KnownStripePrice[];+ }+private async getPrice(lookupKey: LookupKey): Promise<KnownStripePrice | null> {@@ -485,35 +478,6 @@ export class SubscriptionService {: null;}- private async getCouponFromPromotionCode(- userFacingPromotionCode: string,- customer: UserStripeCustomer- ) {- const list = await this.stripe.promotionCodes.list({- code: userFacingPromotionCode,- active: true,- limit: 1,- });-- const code = list.data[0];- if (!code) {- return null;- }-- // the coupons are always bound to products, we need to check it first- // but the logic would be too complicated, and stripe will complain if the code is not applicable when checking out- // It's safe to skip the check here- // code.coupon.applies_to.products.forEach()-- // check if the code is bound to a specific customer- return !code.customer ||- (typeof code.customer === 'string'- ? code.customer === customer.stripeCustomerId- : code.customer.id === customer.stripeCustomerId)- ? code.coupon.id- : null;- }-private async parseStripeInvoice(invoice: Stripe.Invoice): Promise<KnownStripeInvoice | null> {@@ -549,10 +513,13 @@ export class SubscriptionService {userId: user.id,stripeInvoice: invoice,lookupKey,+ metadata: invoice.subscription_details?.metadata ?? {},};}- private async parseStripeSubscription(subscription: Stripe.Subscription) {+ private async parseStripeSubscription(+ subscription: Stripe.Subscription+ ): Promise<KnownStripeSubscription | null> {const lookupKey = retriveLookupKeyFromStripeSubscription(subscription);if (!lookupKey) {@@ -569,6 +536,8 @@ export class SubscriptionService {userId,lookupKey,stripeSubscription: subscription,+ quantity: subscription.items.data[0]?.quantity ?? 1,+ metadata: subscription.metadata,};}@@ -582,4 +551,14 @@ export class SubscriptionService {}: null;}++ private assertSubscriptionIdentity(+ args: z.infer<typeof SubscriptionIdentity>+ ) {+ const result = SubscriptionIdentity.safeParse(args);++ if (!result.success) {+ throw new InvalidSubscriptionParameters();+ }+ }}diff --git a/packages/backend/server/src/plugins/payment/types.ts b/packages/backend/server/src/plugins/payment/types.tsindex 196c57d98e..efb09089b9 100644--- a/packages/backend/server/src/plugins/payment/types.ts+++ b/packages/backend/server/src/plugins/payment/types.ts@@ -1,4 +1,4 @@-import type { User } from '@prisma/client';+import type { User, Workspace } from '@prisma/client';import Stripe from 'stripe';import type { Payload } from '../../fundamentals/event/def';@@ -64,12 +64,31 @@ declare module '../../fundamentals/event/def' {}>;};}++ interface WorkspaceEvents {+ subscription: {+ activated: Payload<{+ workspaceId: Workspace['id'];+ plan: SubscriptionPlan;+ recurring: SubscriptionRecurring;+ quantity: number;+ }>;+ canceled: Payload<{+ workspaceId: Workspace['id'];+ plan: SubscriptionPlan;+ recurring: SubscriptionRecurring;+ }>;+ };+ members: {+ updated: Payload<{ workspaceId: Workspace['id']; count: number }>;+ };+ }}export interface LookupKey {plan: SubscriptionPlan;recurring: SubscriptionRecurring;- variant?: SubscriptionVariant;+ variant: SubscriptionVariant | null;}export interface KnownStripeInvoice {@@ -87,6 +106,11 @@ export interface KnownStripeInvoice {* The invoice object from Stripe.*/stripeInvoice: Stripe.Invoice;++ /**+ * The metadata of the subscription related to the invoice.+ */+ metadata: Record<string, string>;}export interface KnownStripeSubscription {@@ -104,6 +128,16 @@ export interface KnownStripeSubscription {* The subscription object from Stripe.*/stripeSubscription: Stripe.Subscription;++ /**+ * The quantity of the subscription items.+ */+ quantity: number;++ /**+ * The metadata of the subscription.+ */+ metadata: Record<string, string>;}export interface KnownStripePrice {@@ -167,7 +201,7 @@ export function decodeLookupKey(key: string): LookupKey | null {return {plan: plan as SubscriptionPlan,recurring: recurring as SubscriptionRecurring,- variant: variant as SubscriptionVariant | undefined,+ variant: variant as SubscriptionVariant,};}diff --git a/packages/backend/server/src/schema.gql b/packages/backend/server/src/schema.gqlindex 505ac394a1..bd3651b7af 100644--- a/packages/backend/server/src/schema.gql+++ b/packages/backend/server/src/schema.gql@@ -140,6 +140,7 @@ input CreateChatSessionInput {}input CreateCheckoutSessionInput {+ args: JSONObjectcoupon: StringidempotencyKey: Stringplan: SubscriptionPlan = Pro@@ -208,7 +209,7 @@ type EditorType {name: String!}-union ErrorDataUnion = AlreadyInSpaceDataType | BlobNotFoundDataType | CopilotMessageNotFoundDataType | CopilotPromptNotFoundDataType | CopilotProviderSideErrorDataType | DocAccessDeniedDataType | DocHistoryNotFoundDataType | DocNotFoundDataType | InvalidEmailDataType | InvalidHistoryTimestampDataType | InvalidPasswordLengthDataType | InvalidRuntimeConfigTypeDataType | MissingOauthQueryParameterDataType | NotInSpaceDataType | RuntimeConfigNotFoundDataType | SameSubscriptionRecurringDataType | SpaceAccessDeniedDataType | SpaceNotFoundDataType | SpaceOwnerNotFoundDataType | SubscriptionAlreadyExistsDataType | SubscriptionNotExistsDataType | SubscriptionPlanNotFoundDataType | UnknownOauthProviderDataType | VersionRejectedDataType+union ErrorDataUnion = AlreadyInSpaceDataType | BlobNotFoundDataType | CopilotMessageNotFoundDataType | CopilotPromptNotFoundDataType | CopilotProviderSideErrorDataType | DocAccessDeniedDataType | DocHistoryNotFoundDataType | DocNotFoundDataType | InvalidEmailDataType | InvalidHistoryTimestampDataType | InvalidPasswordLengthDataType | InvalidRuntimeConfigTypeDataType | MissingOauthQueryParameterDataType | NotInSpaceDataType | RuntimeConfigNotFoundDataType | SameSubscriptionRecurringDataType | SpaceAccessDeniedDataType | SpaceNotFoundDataType | SpaceOwnerNotFoundDataType | SubscriptionAlreadyExistsDataType | SubscriptionNotExistsDataType | SubscriptionPlanNotFoundDataType | UnknownOauthProviderDataType | UnsupportedSubscriptionPlanDataType | VersionRejectedDataTypeenum ErrorNames {ACCESS_DENIED@@ -246,12 +247,14 @@ enum ErrorNames {FAILED_TO_SAVE_UPDATESFAILED_TO_UPSERT_SNAPSHOTINTERNAL_SERVER_ERROR+ INVALID_CHECKOUT_PARAMETERSINVALID_EMAILINVALID_EMAIL_TOKENINVALID_HISTORY_TIMESTAMPINVALID_OAUTH_CALLBACK_STATEINVALID_PASSWORD_LENGTHINVALID_RUNTIME_CONFIG_TYPE+ INVALID_SUBSCRIPTION_PARAMETERSLINK_EXPIREDMAILER_SERVICE_IS_NOT_CONFIGUREDMEMBER_QUOTA_EXCEEDED@@ -273,14 +276,18 @@ enum ErrorNames {SUBSCRIPTION_ALREADY_EXISTSSUBSCRIPTION_EXPIREDSUBSCRIPTION_HAS_BEEN_CANCELED+ SUBSCRIPTION_HAS_NOT_BEEN_CANCELEDSUBSCRIPTION_NOT_EXISTSSUBSCRIPTION_PLAN_NOT_FOUNDTOO_MANY_REQUESTUNKNOWN_OAUTH_PROVIDERUNSPLASH_IS_NOT_CONFIGURED+ UNSUPPORTED_SUBSCRIPTION_PLANUSER_AVATAR_NOT_FOUNDUSER_NOT_FOUNDVERSION_REJECTED+ WORKSPACE_ID_REQUIRED_FOR_TEAM_SUBSCRIPTION+ WORKSPACE_ID_REQUIRED_TO_UPDATE_TEAM_SUBSCRIPTIONWRONG_SIGN_IN_CREDENTIALSWRONG_SIGN_IN_METHOD}@@ -444,7 +451,7 @@ type MissingOauthQueryParameterDataType {type Mutation {acceptInviteById(inviteId: String!, sendAcceptMail: Boolean, workspaceId: String!): Boolean!addWorkspaceFeature(feature: FeatureType!, workspaceId: String!): Int!- cancelSubscription(idempotencyKey: String @deprecated(reason: "use header `Idempotency-Key`"), plan: SubscriptionPlan = Pro): SubscriptionType!+ cancelSubscription(idempotencyKey: String @deprecated(reason: "use header `Idempotency-Key`"), plan: SubscriptionPlan = Pro, workspaceId: String): SubscriptionType!changeEmail(email: String!, token: String!): UserType!changePassword(newPassword: String!, token: String!, userId: String): Boolean!@@ -491,7 +498,7 @@ type Mutation {"""Remove user avatar"""removeAvatar: RemoveAvatar!removeWorkspaceFeature(feature: FeatureType!, workspaceId: String!): Int!- resumeSubscription(idempotencyKey: String @deprecated(reason: "use header `Idempotency-Key`"), plan: SubscriptionPlan = Pro): SubscriptionType!+ resumeSubscription(idempotencyKey: String @deprecated(reason: "use header `Idempotency-Key`"), plan: SubscriptionPlan = Pro, workspaceId: String): SubscriptionType!revoke(userId: String!, workspaceId: String!): Boolean!revokePage(pageId: String!, workspaceId: String!): Boolean! @deprecated(reason: "use revokePublicPage")revokePublicPage(pageId: String!, workspaceId: String!): WorkspacePage!@@ -513,7 +520,7 @@ type Mutation {"""update multiple server runtime configurable settings"""updateRuntimeConfigs(updates: JSONObject!): [ServerRuntimeConfigType!]!- updateSubscriptionRecurring(idempotencyKey: String @deprecated(reason: "use header `Idempotency-Key`"), plan: SubscriptionPlan = Pro, recurring: SubscriptionRecurring!): SubscriptionType!+ updateSubscriptionRecurring(idempotencyKey: String @deprecated(reason: "use header `Idempotency-Key`"), plan: SubscriptionPlan = Pro, recurring: SubscriptionRecurring!, workspaceId: String): SubscriptionType!"""Update a user"""updateUser(id: String!, input: ManageUserInput!): UserType!@@ -814,6 +821,10 @@ type UnknownOauthProviderDataType {name: String!}+type UnsupportedSubscriptionPlanDataType {+ plan: String!+}+input UpdateUserInput {"""User name"""name: String@@ -929,6 +940,10 @@ type WorkspaceType {"""is current workspace initialized"""initialized: Boolean!+ """Get user invoice count"""+ invoiceCount: Int!+ invoices(skip: Int, take: Int = 8): [InvoiceType!]!+"""member count of workspace"""memberCount: Int!@@ -958,6 +973,9 @@ type WorkspaceType {"""Shared pages of workspace"""sharedPages: [String!]! @deprecated(reason: "use WorkspaceType.publicPages")++ """The team subscription of the workspace, if exists."""+ subscription: SubscriptionType}type tokenType {diff --git a/packages/backend/server/tests/payment/service.spec.ts b/packages/backend/server/tests/payment/service.spec.tsindex 2692ccc8a5..2d8eee2055 100644--- a/packages/backend/server/tests/payment/service.spec.ts+++ b/packages/backend/server/tests/payment/service.spec.ts@@ -14,7 +14,7 @@ import {FeatureManagementService,} from '../../src/core/features';import { EventEmitter } from '../../src/fundamentals';-import { Config, ConfigModule } from '../../src/fundamentals/config';+import { Config, ConfigModule, Runtime } from '../../src/fundamentals/config';import { SubscriptionService } from '../../src/plugins/payment/service';import {CouponType,@@ -32,6 +32,8 @@ const PRO_LIFETIME = `${SubscriptionPlan.Pro}_${SubscriptionRecurring.Lifetime}`const PRO_EA_YEARLY = `${SubscriptionPlan.Pro}_${SubscriptionRecurring.Yearly}_${SubscriptionVariant.EA}`;const AI_YEARLY = `${SubscriptionPlan.AI}_${SubscriptionRecurring.Yearly}`;const AI_YEARLY_EA = `${SubscriptionPlan.AI}_${SubscriptionRecurring.Yearly}_${SubscriptionVariant.EA}`;+const TEAM_MONTHLY = `${SubscriptionPlan.Team}_${SubscriptionRecurring.Monthly}`;+const TEAM_YEARLY = `${SubscriptionPlan.Team}_${SubscriptionRecurring.Yearly}`;// prices for code redeemingconst PRO_MONTHLY_CODE = `${SubscriptionPlan.Pro}_${SubscriptionRecurring.Monthly}_${SubscriptionVariant.Onetime}`;const PRO_YEARLY_CODE = `${SubscriptionPlan.Pro}_${SubscriptionRecurring.Yearly}_${SubscriptionVariant.Onetime}`;@@ -107,6 +109,18 @@ const PRICES = {id: AI_YEARLY_CODE,lookup_key: AI_YEARLY_CODE,},+ [TEAM_MONTHLY]: {+ unit_amount: 1500,+ currency: 'usd',+ id: TEAM_MONTHLY,+ lookup_key: TEAM_MONTHLY,+ },+ [TEAM_YEARLY]: {+ unit_amount: 14400,+ currency: 'usd',+ id: TEAM_YEARLY,+ lookup_key: TEAM_YEARLY,+ },} as any as Record<string, Stripe.Price>;const sub: Stripe.Subscription = {@@ -139,6 +153,7 @@ const sub: Stripe.Subscription = {trial_end: null,trial_start: null,schedule: null,+ metadata: {},};const test = ava as TestFn<{@@ -148,6 +163,7 @@ const test = ava as TestFn<{service: SubscriptionService;event: Sinon.SinonStubbedInstance<EventEmitter>;feature: Sinon.SinonStubbedInstance<FeatureManagementService>;+ runtime: Sinon.SinonStubbedInstance<Runtime>;stripe: {customers: Sinon.SinonStubbedInstance<Stripe.CustomersResource>;prices: Sinon.SinonStubbedInstance<Stripe.PricesResource>;@@ -156,6 +172,7 @@ const test = ava as TestFn<{checkout: {sessions: Sinon.SinonStubbedInstance<Stripe.Checkout.SessionsResource>;};+ promotionCodes: Sinon.SinonStubbedInstance<Stripe.PromotionCodesResource>;};}>;@@ -192,12 +209,14 @@ test.before(async t => {m.overrideProvider(EventEmitter).useValue(Sinon.createStubInstance(EventEmitter));+ m.overrideProvider(Runtime).useValue(Sinon.createStubInstance(Runtime));},});t.context.event = app.get(EventEmitter);t.context.service = app.get(SubscriptionService);t.context.feature = app.get(FeatureManagementService);+ t.context.runtime = app.get(Runtime);t.context.db = app.get(PrismaClient);t.context.app = app;@@ -210,6 +229,7 @@ test.before(async t => {checkout: {sessions: Sinon.stub(stripe.checkout.sessions),},+ promotionCodes: Sinon.stub(stripe.promotionCodes),};t.context.stripe = stripeStubs;@@ -219,10 +239,17 @@ test.beforeEach(async t => {const { db, app, stripe } = t.context;Sinon.reset();await initTestingDB(db);- // TODO(@forehalo): workaround for runtime module, need to init all runtime configs in [initTestingDB]- await app.get(Config).runtime.onModuleInit();+ t.context.runtime.fetch+ .withArgs('plugins.payment/showLifetimePrice')+ .resolves(true);t.context.u1 = await app.get(AuthService).signUp('[email protected]', '1');+ await db.workspace.create({+ data: {+ id: 'ws_1',+ public: false,+ },+ });await db.userStripeCustomer.create({data: {userId: t.context.u1.id,@@ -270,6 +297,15 @@ test('should list normal prices for authenticated user', async t => {t.snapshot(prices.map(p => encodeLookupKey(p.lookupKey)));});+test('should not show lifetime price if not enabled', async t => {+ const { service, runtime } = t.context;+ runtime.fetch.withArgs('plugins.payment/showLifetimePrice').resolves(false);++ const prices = await service.listPrices(t.context.u1);++ t.snapshot(prices.map(p => encodeLookupKey(p.lookupKey)));+});+test('should list early access prices for pro ea user', async t => {const { feature, service, u1 } = t.context;@@ -368,9 +404,9 @@ test('should list normal prices for ai ea user with old subscriptions', async ttest('should throw if user has subscription already', async t => {const { service, u1, db } = t.context;- await db.userSubscription.create({+ await db.subscription.create({data: {- userId: u1.id,+ targetId: u1.id,stripeSubscriptionId: 'sub_1',plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,@@ -382,15 +418,14 @@ test('should throw if user has subscription already', async t => {await t.throwsAsync(() =>- service.checkout({- user: u1,- lookupKey: {+ service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- }),+ { user: u1 }+ ),{ message: 'You have already subscribed to the pro plan.' });});@@ -401,15 +436,14 @@ test('should get correct pro plan price for checking out', async t => {{feature.isEarlyAccessUser.resolves(false);- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ { user: u1 }+ );t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {price: PRO_MONTHLY,@@ -420,15 +454,14 @@ test('should get correct pro plan price for checking out', async t => {// ea user, but monthly{feature.isEarlyAccessUser.resolves(true);- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ { user: u1 }+ );t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {price: PRO_MONTHLY,@@ -439,16 +472,15 @@ test('should get correct pro plan price for checking out', async t => {// ea user, yearly{feature.isEarlyAccessUser.resolves(true);- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Yearly,variant: SubscriptionVariant.EA,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ { user: u1 }+ );t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {price: PRO_EA_YEARLY,@@ -478,15 +510,14 @@ test('should get correct pro plan price for checking out', async t => {],});- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Yearly,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ { user: u1 }+ );t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {price: PRO_YEARLY,@@ -495,16 +526,15 @@ test('should get correct pro plan price for checking out', async t => {await t.throwsAsync(() =>- service.checkout({- user: u1,- lookupKey: {+ service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Yearly,variant: SubscriptionVariant.EA,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- }),+ { user: u1 }+ ),{message: 'You are trying to access a unknown subscription plan.',}@@ -517,15 +547,14 @@ test('should get correct pro plan price for checking out', async t => {const config = app.get(Config);await config.runtime.set('plugins.payment/showLifetimePrice', true);- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Lifetime,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ { user: u1 }+ );t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {price: PRO_LIFETIME,@@ -541,15 +570,14 @@ test('should get correct ai plan price for checking out', async t => {{feature.isEarlyAccessUser.resolves(false);- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.AI,recurring: SubscriptionRecurring.Yearly,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ { user: u1 }+ );t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {price: AI_YEARLY,@@ -561,16 +589,15 @@ test('should get correct ai plan price for checking out', async t => {{feature.isEarlyAccessUser.resolves(true);- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.AI,recurring: SubscriptionRecurring.Yearly,variant: SubscriptionVariant.EA,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ { user: u1 }+ );t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {price: AI_YEARLY_EA,@@ -603,15 +630,14 @@ test('should get correct ai plan price for checking out', async t => {],});- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.AI,recurring: SubscriptionRecurring.Yearly,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ { user: u1 }+ );t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {price: AI_YEARLY,@@ -620,16 +646,15 @@ test('should get correct ai plan price for checking out', async t => {await t.throwsAsync(() =>- service.checkout({- user: u1,- lookupKey: {+ service.checkout(+ {plan: SubscriptionPlan.AI,recurring: SubscriptionRecurring.Yearly,variant: SubscriptionVariant.EA,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- }),+ { user: u1 }+ ),{message: 'You are trying to access a unknown subscription plan.',}@@ -645,15 +670,14 @@ test('should get correct ai plan price for checking out', async t => {// @ts-expect-error stubstripe.subscriptions.list.resolves({ data: [] });- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.AI,recurring: SubscriptionRecurring.Yearly,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ { user: u1 }+ );t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {price: AI_YEARLY,@@ -686,15 +710,14 @@ test('should get correct ai plan price for checking out', async t => {],});- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.AI,recurring: SubscriptionRecurring.Yearly,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ { user: u1 }+ );t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {price: AI_YEARLY,@@ -706,19 +729,26 @@ test('should get correct ai plan price for checking out', async t => {test('should apply user coupon for checking out', async t => {const { service, u1, stripe } = t.context;- // @ts-expect-error private member- Sinon.stub(service, 'getCouponFromPromotionCode').resolves('coupon_1');+ stripe.promotionCodes.list.resolves({+ data: [+ {+ // @ts-expect-error mock+ coupon: {+ id: 'coupon_1',+ },+ },+ ],+ });- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,+ successCallbackLink: '',+ coupon: 'test',},- redirectUrl: '',- idempotencyKey: '',- promotionCode: 'test',- });+ { user: u1 }+ );t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {price: PRO_MONTHLY,@@ -732,8 +762,8 @@ test('should be able to create subscription', async t => {await service.saveStripeSubscription(sub);- const subInDB = await db.userSubscription.findFirst({- where: { userId: u1.id },+ const subInDB = await db.subscription.findFirst({+ where: { targetId: u1.id },});t.true(@@ -764,8 +794,8 @@ test('should be able to update subscription', async t => {}));- const subInDB = await db.userSubscription.findFirst({- where: { userId: u1.id },+ const subInDB = await db.subscription.findFirst({+ where: { targetId: u1.id },});t.is(subInDB?.status, SubscriptionStatus.Active);@@ -789,8 +819,8 @@ test('should be able to delete subscription', async t => {}));- const subInDB = await db.userSubscription.findFirst({- where: { userId: u1.id },+ const subInDB = await db.subscription.findFirst({+ where: { targetId: u1.id },});t.is(subInDB, null);@@ -799,9 +829,9 @@ test('should be able to delete subscription', async t => {test('should be able to cancel subscription', async t => {const { service, db, u1, stripe } = t.context;- await db.userSubscription.create({+ await db.subscription.create({data: {- userId: u1.id,+ targetId: u1.id,stripeSubscriptionId: 'sub_1',plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Yearly,@@ -817,7 +847,10 @@ test('should be able to cancel subscription', async t => {canceled_at: 1714118236,} as any);- const subInDB = await service.cancelSubscription(u1.id, SubscriptionPlan.Pro);+ const subInDB = await service.cancelSubscription({+ userId: u1.id,+ plan: SubscriptionPlan.Pro,+ });t.true(stripe.subscriptions.update.calledOnceWith('sub_1', {@@ -831,9 +864,9 @@ test('should be able to cancel subscription', async t => {test('should be able to resume subscription', async t => {const { service, db, u1, stripe } = t.context;- await db.userSubscription.create({+ await db.subscription.create({data: {- userId: u1.id,+ targetId: u1.id,stripeSubscriptionId: 'sub_1',plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Yearly,@@ -846,7 +879,10 @@ test('should be able to resume subscription', async t => {stripe.subscriptions.update.resolves(sub as any);- const subInDB = await service.resumeSubscription(u1.id, SubscriptionPlan.Pro);+ const subInDB = await service.resumeSubscription({+ userId: u1.id,+ plan: SubscriptionPlan.Pro,+ });t.true(stripe.subscriptions.update.calledOnceWith('sub_1', {@@ -868,10 +904,21 @@ const subscriptionSchedule: Stripe.SubscriptionSchedule = {// @ts-expect-error mock{price: PRO_MONTHLY,+ quantity: 1,+ },+ ],+ start_date: Math.floor(Date.now() / 1000),+ end_date: Math.floor((Date.now() + 30 * 24 * 60 * 60 * 1000) / 1000),+ },+ {+ items: [+ // @ts-expect-error mock+ {+ price: PRO_YEARLY,+ quantity: 1,},],- start_date: 1714118236,- end_date: 1745654236,+ start_date: Math.floor((Date.now() + 30 * 24 * 60 * 60 * 1000) / 1000),},],};@@ -879,9 +926,9 @@ const subscriptionSchedule: Stripe.SubscriptionSchedule = {test('should be able to update recurring', async t => {const { service, db, u1, stripe } = t.context;- await db.userSubscription.create({+ await db.subscription.create({data: {- userId: u1.id,+ targetId: u1.id,stripeSubscriptionId: 'sub_1',plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,@@ -892,51 +939,54 @@ test('should be able to update recurring', async t => {});// 1. turn a subscription into a subscription schedule- // 2. update the schedule- // 2.1 update the current phase with an end date- // 2.2 add a new phase with a start date-+ // 2. update the current phase with an end datestripe.subscriptions.retrieve.resolves(sub as any);stripe.subscriptionSchedules.create.resolves(subscriptionSchedule as any);stripe.subscriptionSchedules.update.resolves(subscriptionSchedule as any);await service.updateSubscriptionRecurring(- u1.id,- SubscriptionPlan.Pro,+ {+ userId: u1.id,+ plan: SubscriptionPlan.Pro,+ },SubscriptionRecurring.Yearly);- t.true(stripe.subscriptionSchedules.update.calledOnce);- const arg = stripe.subscriptionSchedules.update.firstCall.args;- t.is(arg[0], subscriptionSchedule.id);- t.deepEqual(arg[1], {- phases: [+ t.true(+ stripe.subscriptionSchedules.update.calledOnceWith(+ subscriptionSchedule.id,{- items: [+ phases: [{- price: PRO_MONTHLY,+ items: [+ {+ price: PRO_MONTHLY,+ quantity: 1,+ },+ ],+ start_date: subscriptionSchedule.phases[0].start_date,+ end_date: subscriptionSchedule.phases[0].end_date,},- ],- start_date: 1714118236,- end_date: 1745654236,- },- {- items: [{- price: PRO_YEARLY,+ items: [+ {+ price: PRO_YEARLY,+ quantity: 1,+ },+ ],},],- },- ],- });+ }+ )+ );});test('should release the schedule if the new recurring is the same as the current phase', async t => {const { service, db, u1, stripe } = t.context;- await db.userSubscription.create({+ await db.subscription.create({data: {- userId: u1.id,+ targetId: u1.id,stripeSubscriptionId: 'sub_1',stripeScheduleId: 'sub_sched_1',plan: SubscriptionPlan.Pro,@@ -953,15 +1003,129 @@ test('should release the schedule if the new recurring is the same as the curren} as any);stripe.subscriptionSchedules.retrieve.resolves(subscriptionSchedule as any);- await service.updateSubscriptionRecurring(- u1.id,- SubscriptionPlan.Pro,+ const subInDB = await service.updateSubscriptionRecurring(+ {+ userId: u1.id,+ plan: SubscriptionPlan.Pro,+ },SubscriptionRecurring.Monthly);t.true(stripe.subscriptionSchedules.release.calledOnceWith(subscriptionSchedule.id));++ t.is(subInDB.recurring, SubscriptionRecurring.Monthly);+});++test('should be able to cancel subscription with schedule', async t => {+ const { service, u1, stripe } = t.context;++ await service.saveStripeSubscription({+ ...sub,+ schedule: 'sub_sched_1',+ });++ stripe.subscriptionSchedules.retrieve.resolves(subscriptionSchedule as any);++ const subInDB = await service.cancelSubscription({+ userId: u1.id,+ plan: SubscriptionPlan.Pro,+ });++ t.true(+ stripe.subscriptionSchedules.update.calledOnceWith(+ subscriptionSchedule.id,+ {+ phases: [+ {+ items: [+ {+ price: PRO_MONTHLY,+ quantity: 1,+ },+ ],+ coupon: undefined,+ start_date: subscriptionSchedule.phases[0].start_date,+ end_date: subscriptionSchedule.phases[0].end_date,+ metadata: {+ next_coupon: null,+ next_price: PRO_YEARLY,+ },+ },+ ],+ end_behavior: 'cancel',+ }+ )+ );++ t.is(subInDB.status, SubscriptionStatus.Active);+ t.truthy(subInDB.canceledAt);+ t.falsy(subInDB.nextBillAt);+});++test('should be able to resume subscription with schedule', async t => {+ const { service, u1, stripe } = t.context;++ await service.saveStripeSubscription({+ ...sub,+ canceled_at: 1714118236,+ schedule: 'sub_sched_1',+ });++ stripe.subscriptionSchedules.retrieve.resolves({+ ...subscriptionSchedule,+ phases: [+ {+ items: [+ // @ts-expect-error mock+ {+ price: PRO_MONTHLY,+ quantity: 1,+ },+ ],+ start_date: subscriptionSchedule.phases[0].start_date,+ end_date: subscriptionSchedule.phases[0].end_date,+ metadata: {+ next_price: PRO_YEARLY,+ },+ },+ ],+ end_behavior: 'cancel',+ });++ const subInDB = await service.resumeSubscription({+ userId: u1.id,+ plan: SubscriptionPlan.Pro,+ });++ t.true(+ stripe.subscriptionSchedules.update.calledOnceWith(+ subscriptionSchedule.id,+ {+ phases: [+ {+ items: [{ price: PRO_MONTHLY, quantity: 1 }],+ start_date: subscriptionSchedule.phases[0].start_date,+ end_date: subscriptionSchedule.phases[0].end_date,+ metadata: {+ next_price: null,+ next_coupon: null,+ },+ },+ {+ items: [{ price: PRO_YEARLY, quantity: 1 }],+ coupon: undefined,+ },+ ],+ end_behavior: 'release',+ }+ )+ );++ t.is(subInDB.status, SubscriptionStatus.Active);+ t.falsy(subInDB.canceledAt);+ t.truthy(subInDB.nextBillAt);});// ============== Lifetime Subscription ===============@@ -1023,38 +1187,40 @@ const onetimeYearlyInvoice: Stripe.Invoice = {};test('should not be able to checkout for lifetime recurring if not enabled', async t => {- const { service, u1, app } = t.context;- await app.get(Config).runtime.set('plugins.payment/showLifetimePrice', false);+ const { service, u1, runtime } = t.context;+ runtime.fetch.withArgs('plugins.payment/showLifetimePrice').resolves(false);await t.throwsAsync(() =>- service.checkout({- user: u1,- lookupKey: {+ service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Lifetime,+ variant: null,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- }),+ {+ user: u1,+ }+ ),{ message: 'You are trying to access a unknown subscription plan.' });});test('should be able to checkout for lifetime recurring', async t => {- const { service, u1, app, stripe } = t.context;- const config = app.get(Config);- await config.runtime.set('plugins.payment/showLifetimePrice', true);+ const { service, u1, stripe } = t.context;- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Lifetime,+ variant: null,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ {+ user: u1,+ }+ );t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {price: PRO_LIFETIME,@@ -1065,9 +1231,9 @@ test('should be able to checkout for lifetime recurring', async t => {test('should not be able to checkout for lifetime recurring if already subscribed', async t => {const { service, u1, db } = t.context;- await db.userSubscription.create({+ await db.subscription.create({data: {- userId: u1.id,+ targetId: u1.id,stripeSubscriptionId: null,plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Lifetime,@@ -1078,20 +1244,22 @@ test('should not be able to checkout for lifetime recurring if already subscribeawait t.throwsAsync(() =>- service.checkout({- user: u1,- lookupKey: {+ service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Lifetime,+ variant: null,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- }),+ {+ user: u1,+ }+ ),{ message: 'You have already subscribed to the pro plan.' });- await db.userSubscription.updateMany({- where: { userId: u1.id },+ await db.subscription.updateMany({+ where: { targetId: u1.id },data: {stripeSubscriptionId: null,recurring: SubscriptionRecurring.Monthly,@@ -1102,15 +1270,17 @@ test('should not be able to checkout for lifetime recurring if already subscribeawait t.throwsAsync(() =>- service.checkout({- user: u1,- lookupKey: {+ service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Lifetime,+ variant: null,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- }),+ {+ user: u1,+ }+ ),{ message: 'You have already subscribed to the pro plan.' });});@@ -1121,8 +1291,8 @@ test('should be able to subscribe to lifetime recurring', async t => {await service.saveStripeInvoice(lifetimeInvoice);- const subInDB = await db.userSubscription.findFirst({- where: { userId: u1.id },+ const subInDB = await db.subscription.findFirst({+ where: { targetId: u1.id },});t.true(@@ -1141,9 +1311,9 @@ test('should be able to subscribe to lifetime recurring', async t => {test('should be able to subscribe to lifetime recurring with old subscription', async t => {const { service, stripe, db, u1, event } = t.context;- await db.userSubscription.create({+ await db.subscription.create({data: {- userId: u1.id,+ targetId: u1.id,stripeSubscriptionId: 'sub_1',plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,@@ -1156,8 +1326,8 @@ test('should be able to subscribe to lifetime recurring with old subscription',stripe.subscriptions.cancel.resolves(sub as any);await service.saveStripeInvoice(lifetimeInvoice);- const subInDB = await db.userSubscription.findFirst({- where: { userId: u1.id },+ const subInDB = await db.subscription.findFirst({+ where: { targetId: u1.id },});t.true(@@ -1176,9 +1346,9 @@ test('should be able to subscribe to lifetime recurring with old subscription',test('should not be able to cancel lifetime subscription', async t => {const { service, db, u1 } = t.context;- await db.userSubscription.create({+ await db.subscription.create({data: {- userId: u1.id,+ targetId: u1.id,plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Lifetime,status: SubscriptionStatus.Active,@@ -1188,7 +1358,11 @@ test('should not be able to cancel lifetime subscription', async t => {});await t.throwsAsync(- () => service.cancelSubscription(u1.id, SubscriptionPlan.Pro),+ () =>+ service.cancelSubscription({+ plan: SubscriptionPlan.Pro,+ userId: u1.id,+ }),{ message: 'Onetime payment subscription cannot be canceled.' });});@@ -1196,9 +1370,9 @@ test('should not be able to cancel lifetime subscription', async t => {test('should not be able to update lifetime recurring', async t => {const { service, db, u1 } = t.context;- await db.userSubscription.create({+ await db.subscription.create({data: {- userId: u1.id,+ targetId: u1.id,plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Lifetime,status: SubscriptionStatus.Active,@@ -1210,8 +1384,10 @@ test('should not be able to update lifetime recurring', async t => {await t.throwsAsync(() =>service.updateSubscriptionRecurring(- u1.id,- SubscriptionPlan.Pro,+ {+ plan: SubscriptionPlan.Pro,+ userId: u1.id,+ },SubscriptionRecurring.Monthly),{ message: 'You cannot update an onetime payment subscription.' }@@ -1222,16 +1398,17 @@ test('should not be able to update lifetime recurring', async t => {test('should be able to checkout for onetime payment', async t => {const { service, u1, stripe } = t.context;- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,variant: SubscriptionVariant.Onetime,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ {+ user: u1,+ }+ );t.true(stripe.checkout.sessions.create.calledOnce);const arg = stripe.checkout.sessions.create.firstCall@@ -1246,9 +1423,9 @@ test('should be able to checkout for onetime payment', async t => {test('should be able to checkout onetime payment if previous subscription is onetime', async t => {const { service, u1, stripe, db } = t.context;- await db.userSubscription.create({+ await db.subscription.create({data: {- userId: u1.id,+ targetId: u1.id,stripeSubscriptionId: 'sub_1',plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,@@ -1259,16 +1436,17 @@ test('should be able to checkout onetime payment if previous subscription is one},});- await service.checkout({- user: u1,- lookupKey: {+ await service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,variant: SubscriptionVariant.Onetime,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- });+ {+ user: u1,+ }+ );t.true(stripe.checkout.sessions.create.calledOnce);const arg = stripe.checkout.sessions.create.firstCall@@ -1283,9 +1461,9 @@ test('should be able to checkout onetime payment if previous subscription is onetest('should not be able to checkout out onetime payment if previous subscription is not onetime', async t => {const { service, u1, db } = t.context;- await db.userSubscription.create({+ await db.subscription.create({data: {- userId: u1.id,+ targetId: u1.id,stripeSubscriptionId: 'sub_1',plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,@@ -1297,21 +1475,22 @@ test('should not be able to checkout out onetime payment if previous subscriptioawait t.throwsAsync(() =>- service.checkout({- user: u1,- lookupKey: {+ service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,variant: SubscriptionVariant.Onetime,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- }),+ {+ user: u1,+ }+ ),{ message: 'You have already subscribed to the pro plan.' });- await db.userSubscription.updateMany({- where: { userId: u1.id },+ await db.subscription.updateMany({+ where: { targetId: u1.id },data: {stripeSubscriptionId: null,recurring: SubscriptionRecurring.Lifetime,@@ -1320,16 +1499,17 @@ test('should not be able to checkout out onetime payment if previous subscriptioawait t.throwsAsync(() =>- service.checkout({- user: u1,- lookupKey: {+ service.checkout(+ {plan: SubscriptionPlan.Pro,recurring: SubscriptionRecurring.Monthly,variant: SubscriptionVariant.Onetime,+ successCallbackLink: '',},- redirectUrl: '',- idempotencyKey: '',- }),+ {+ user: u1,+ }+ ),{ message: 'You have already subscribed to the pro plan.' });});@@ -1339,8 +1519,8 @@ test('should be able to subscribe onetime payment subscription', async t => {await service.saveStripeInvoice(onetimeMonthlyInvoice);- const subInDB = await db.userSubscription.findFirst({- where: { userId: u1.id },+ const subInDB = await db.subscription.findFirst({+ where: { targetId: u1.id },});t.true(@@ -1365,16 +1545,16 @@ test('should be able to recalculate onetime payment subscription period', asyncawait service.saveStripeInvoice(onetimeMonthlyInvoice);- let subInDB = await db.userSubscription.findFirst({- where: { userId: u1.id },+ let subInDB = await db.subscription.findFirst({+ where: { targetId: u1.id },});t.truthy(subInDB);let end = subInDB!.end!;await service.saveStripeInvoice(onetimeMonthlyInvoice);- subInDB = await db.userSubscription.findFirst({- where: { userId: u1.id },+ subInDB = await db.subscription.findFirst({+ where: { targetId: u1.id },});// add 30 days@@ -1382,23 +1562,23 @@ test('should be able to recalculate onetime payment subscription period', asyncend = subInDB!.end!;await service.saveStripeInvoice(onetimeYearlyInvoice);- subInDB = await db.userSubscription.findFirst({- where: { userId: u1.id },+ subInDB = await db.subscription.findFirst({+ where: { targetId: u1.id },});// add 365 dayst.is(subInDB!.end!.getTime(), end.getTime() + 365 * 24 * 60 * 60 * 1000);// make subscription expired- await db.userSubscription.update({+ await db.subscription.update({where: { id: subInDB!.id },data: {end: new Date(Date.now() - 1000),},});await service.saveStripeInvoice(onetimeYearlyInvoice);- subInDB = await db.userSubscription.findFirst({- where: { userId: u1.id },+ subInDB = await db.subscription.findFirst({+ where: { targetId: u1.id },});// add 365 days from now@@ -1407,3 +1587,148 @@ test('should be able to recalculate onetime payment subscription period', asyncnew Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toDateString());});++// TEAM+test('should be able to list prices for team', async t => {+ const { service } = t.context;++ const prices = await service.listPrices(undefined);++ t.snapshot(prices.map(p => encodeLookupKey(p.lookupKey)));+});++test('should be able to checkout for team', async t => {+ const { service, u1, stripe } = t.context;++ await service.checkout(+ {+ plan: SubscriptionPlan.Team,+ recurring: SubscriptionRecurring.Monthly,+ variant: null,+ successCallbackLink: '',+ },+ {+ user: u1,+ workspaceId: 'ws_1',+ }+ );++ t.deepEqual(getLastCheckoutPrice(stripe.checkout.sessions.create), {+ price: TEAM_MONTHLY,+ coupon: undefined,+ });+});++test('should not be able to checkout for workspace if subscribed', async t => {+ const { service, u1, db } = t.context;++ await db.subscription.create({+ data: {+ targetId: 'ws_1',+ stripeSubscriptionId: 'sub_1',+ plan: SubscriptionPlan.Team,+ recurring: SubscriptionRecurring.Monthly,+ status: SubscriptionStatus.Active,+ start: new Date(),+ end: new Date(),+ quantity: 1,+ },+ });++ await t.throwsAsync(+ () =>+ service.checkout(+ {+ plan: SubscriptionPlan.Team,+ recurring: SubscriptionRecurring.Monthly,+ variant: null,+ successCallbackLink: '',+ },+ {+ user: u1,+ workspaceId: 'ws_1',+ }+ ),+ { message: 'You have already subscribed to the team plan.' }+ );+});++const teamSub: Stripe.Subscription = {+ ...sub,+ items: {+ object: 'list',+ data: [+ {+ id: 'si_1',+ // @ts-expect-error stub+ price: {+ id: TEAM_MONTHLY,+ lookup_key: 'team_monthly',+ },+ subscription: 'sub_1',+ quantity: 1,+ },+ ],+ },+ metadata: {+ workspaceId: 'ws_1',+ },+};++test('should be able to create team subscription', async t => {+ const { event, service, db } = t.context;++ await service.saveStripeSubscription(teamSub);++ const subInDB = await db.subscription.findFirst({+ where: { targetId: 'ws_1' },+ });++ t.true(+ event.emit.calledOnceWith('workspace.subscription.activated', {+ workspaceId: 'ws_1',+ plan: SubscriptionPlan.Team,+ recurring: SubscriptionRecurring.Monthly,+ quantity: 1,+ })+ );+ t.is(subInDB?.stripeSubscriptionId, sub.id);+});++test('should be able to update team subscription', async t => {+ const { service, db, event } = t.context;++ await service.saveStripeSubscription(teamSub);++ await service.saveStripeSubscription({+ ...teamSub,+ items: {+ ...teamSub.items,+ data: [+ {+ ...teamSub.items.data[0],+ quantity: 2,+ },+ ],+ },+ });++ const subInDB = await db.subscription.findFirst({+ where: { targetId: 'ws_1' },+ });++ t.is(subInDB?.quantity, 2);++ t.true(+ event.emit.calledWith('workspace.subscription.activated', {+ workspaceId: 'ws_1',+ plan: SubscriptionPlan.Team,+ recurring: SubscriptionRecurring.Monthly,+ quantity: 2,+ })+ );+});++// NOTE(@forehalo): cancel and resume a team subscription share the same logic with user subscription+test.skip('should be able to cancel team subscription', async () => {});+test.skip('should be able to resume team subscription', async () => {});diff --git a/packages/backend/server/tests/payment/snapshots/service.spec.ts.md b/packages/backend/server/tests/payment/snapshots/service.spec.ts.mdindex b10c48de78..cbce3754c8 100644--- a/packages/backend/server/tests/payment/snapshots/service.spec.ts.md+++ b/packages/backend/server/tests/payment/snapshots/service.spec.ts.md@@ -11,7 +11,10 @@ Generated by [AVA](https://avajs.dev).['pro_monthly','pro_yearly',+ 'pro_lifetime','ai_yearly',+ 'team_monthly',+ 'team_yearly',]## should list normal prices for authenticated user@@ -21,7 +24,22 @@ Generated by [AVA](https://avajs.dev).['pro_monthly','pro_yearly',+ 'pro_lifetime','ai_yearly',+ 'team_monthly',+ 'team_yearly',+ ]++## should not show lifetime price if not enabled++> Snapshot 1++ [+ 'pro_monthly',+ 'pro_yearly',+ 'ai_yearly',+ 'team_monthly',+ 'team_yearly',]## should list early access prices for pro ea user@@ -30,8 +48,11 @@ Generated by [AVA](https://avajs.dev).['pro_monthly',+ 'pro_lifetime','pro_yearly_earlyaccess','ai_yearly',+ 'team_monthly',+ 'team_yearly',]## should list normal prices for pro ea user with old subscriptions@@ -41,7 +62,10 @@ Generated by [AVA](https://avajs.dev).['pro_monthly','pro_yearly',+ 'pro_lifetime','ai_yearly',+ 'team_monthly',+ 'team_yearly',]## should list early access prices for ai ea user@@ -51,7 +75,10 @@ Generated by [AVA](https://avajs.dev).['pro_monthly','pro_yearly',+ 'pro_lifetime','ai_yearly_earlyaccess',+ 'team_monthly',+ 'team_yearly',]## should list early access prices for pro and ai ea user@@ -60,8 +87,11 @@ Generated by [AVA](https://avajs.dev).['pro_monthly',+ 'pro_lifetime','pro_yearly_earlyaccess','ai_yearly_earlyaccess',+ 'team_monthly',+ 'team_yearly',]## should list normal prices for ai ea user with old subscriptions@@ -71,5 +101,21 @@ Generated by [AVA](https://avajs.dev).['pro_monthly','pro_yearly',+ 'pro_lifetime',+ 'ai_yearly',+ 'team_monthly',+ 'team_yearly',+ ]++## should be able to list prices for team++> Snapshot 1++ [+ 'pro_monthly',+ 'pro_yearly',+ 'pro_lifetime','ai_yearly',+ 'team_monthly',+ 'team_yearly',]diff --git a/packages/backend/server/tests/payment/snapshots/service.spec.ts.snap b/packages/backend/server/tests/payment/snapshots/service.spec.ts.snapindex e442c5ca70..165ed37186 100644Binary files a/packages/backend/server/tests/payment/snapshots/service.spec.ts.snap and b/packages/backend/server/tests/payment/snapshots/service.spec.ts.snap differdiff --git a/packages/frontend/core/src/modules/cloud/stores/subscription.ts b/packages/frontend/core/src/modules/cloud/stores/subscription.tsindex 144695f28d..5e32a1eac6 100644--- a/packages/frontend/core/src/modules/cloud/stores/subscription.ts+++ b/packages/frontend/core/src/modules/cloud/stores/subscription.ts@@ -23,7 +23,7 @@ const SUBSCRIPTION_CACHE_KEY = 'subscription:';const getDefaultSubscriptionSuccessCallbackLink = (baseUrl: string,- plan: SubscriptionPlan | null,+ plan?: SubscriptionPlan | null,scheme?: string) => {const path =diff --git a/packages/frontend/graphql/codegen.yml b/packages/frontend/graphql/codegen.ymlindex 220382380c..9ae652f4e6 100644--- a/packages/frontend/graphql/codegen.yml+++ b/packages/frontend/graphql/codegen.yml@@ -5,7 +5,11 @@ config:strict: truemaybeValue: T | nulldeclarationKind: interface- avoidOptionals: true+ avoidOptionals:+ field: true+ inputValue: false+ object: false+ defaultValue: falsepreResolveTypes: truenamingConvention:enumValues: keepdiff --git a/packages/frontend/graphql/src/schema.ts b/packages/frontend/graphql/src/schema.tsindex 5ee8fb8f35..30d609acb1 100644--- a/packages/frontend/graphql/src/schema.ts+++ b/packages/frontend/graphql/src/schema.ts@@ -77,8 +77,8 @@ export interface Copilot {}export interface CopilotHistoriesArgs {- docId: InputMaybe<Scalars['String']['input']>;- options: InputMaybe<QueryChatHistoriesInput>;+ docId?: InputMaybe<Scalars['String']['input']>;+ options?: InputMaybe<QueryChatHistoriesInput>;}export interface CopilotHistories {@@ -111,11 +111,11 @@ export enum CopilotModels {}export interface CopilotPromptConfigInput {- frequencyPenalty: InputMaybe<Scalars['Float']['input']>;- jsonMode: InputMaybe<Scalars['Boolean']['input']>;- presencePenalty: InputMaybe<Scalars['Float']['input']>;- temperature: InputMaybe<Scalars['Float']['input']>;- topP: InputMaybe<Scalars['Float']['input']>;+ frequencyPenalty?: InputMaybe<Scalars['Float']['input']>;+ jsonMode?: InputMaybe<Scalars['Boolean']['input']>;+ presencePenalty?: InputMaybe<Scalars['Float']['input']>;+ temperature?: InputMaybe<Scalars['Float']['input']>;+ topP?: InputMaybe<Scalars['Float']['input']>;}export interface CopilotPromptConfigType {@@ -129,7 +129,7 @@ export interface CopilotPromptConfigType {export interface CopilotPromptMessageInput {content: Scalars['String']['input'];- params: InputMaybe<Scalars['JSON']['input']>;+ params?: InputMaybe<Scalars['JSON']['input']>;role: CopilotPromptMessageRole;}@@ -174,10 +174,10 @@ export interface CopilotQuota {}export interface CreateChatMessageInput {- attachments: InputMaybe<Array<Scalars['String']['input']>>;- blobs: InputMaybe<Array<Scalars['Upload']['input']>>;- content: InputMaybe<Scalars['String']['input']>;- params: InputMaybe<Scalars['JSON']['input']>;+ attachments?: InputMaybe<Array<Scalars['String']['input']>>;+ blobs?: InputMaybe<Array<Scalars['Upload']['input']>>;+ content?: InputMaybe<Scalars['String']['input']>;+ params?: InputMaybe<Scalars['JSON']['input']>;sessionId: Scalars['String']['input'];}@@ -189,17 +189,19 @@ export interface CreateChatSessionInput {}export interface CreateCheckoutSessionInput {- coupon: InputMaybe<Scalars['String']['input']>;- idempotencyKey: InputMaybe<Scalars['String']['input']>;- plan: InputMaybe<SubscriptionPlan>;- recurring: InputMaybe<SubscriptionRecurring>;+ args?: InputMaybe<Scalars['JSONObject']['input']>;+ coupon?: InputMaybe<Scalars['String']['input']>;+ idempotencyKey?: InputMaybe<Scalars['String']['input']>;+ plan?: InputMaybe<SubscriptionPlan>;+ quantity?: InputMaybe<Scalars['Int']['input']>;+ recurring?: InputMaybe<SubscriptionRecurring>;successCallbackLink: Scalars['String']['input'];- variant: InputMaybe<SubscriptionVariant>;+ variant?: InputMaybe<SubscriptionVariant>;}export interface CreateCopilotPromptInput {- action: InputMaybe<Scalars['String']['input']>;- config: InputMaybe<CopilotPromptConfigInput>;+ action?: InputMaybe<Scalars['String']['input']>;+ config?: InputMaybe<CopilotPromptConfigInput>;messages: Array<CopilotPromptMessageInput>;model: CopilotModels;name: Scalars['String']['input'];@@ -207,7 +209,7 @@ export interface CreateCopilotPromptInput {export interface CreateUserInput {email: Scalars['String']['input'];- name: InputMaybe<Scalars['String']['input']>;+ name?: InputMaybe<Scalars['String']['input']>;}export interface CredentialsRequirementType {@@ -283,6 +285,7 @@ export type ErrorDataUnion =| SubscriptionNotExistsDataType| SubscriptionPlanNotFoundDataType| UnknownOauthProviderDataType+ | UnsupportedSubscriptionPlanDataType| VersionRejectedDataType;export enum ErrorNames {@@ -321,12 +324,14 @@ export enum ErrorNames {FAILED_TO_SAVE_UPDATES = 'FAILED_TO_SAVE_UPDATES',FAILED_TO_UPSERT_SNAPSHOT = 'FAILED_TO_UPSERT_SNAPSHOT',INTERNAL_SERVER_ERROR = 'INTERNAL_SERVER_ERROR',+ INVALID_CHECKOUT_PARAMETERS = 'INVALID_CHECKOUT_PARAMETERS',INVALID_EMAIL = 'INVALID_EMAIL',INVALID_EMAIL_TOKEN = 'INVALID_EMAIL_TOKEN',INVALID_HISTORY_TIMESTAMP = 'INVALID_HISTORY_TIMESTAMP',INVALID_OAUTH_CALLBACK_STATE = 'INVALID_OAUTH_CALLBACK_STATE',INVALID_PASSWORD_LENGTH = 'INVALID_PASSWORD_LENGTH',INVALID_RUNTIME_CONFIG_TYPE = 'INVALID_RUNTIME_CONFIG_TYPE',+ INVALID_SUBSCRIPTION_PARAMETERS = 'INVALID_SUBSCRIPTION_PARAMETERS',LINK_EXPIRED = 'LINK_EXPIRED',MAILER_SERVICE_IS_NOT_CONFIGURED = 'MAILER_SERVICE_IS_NOT_CONFIGURED',MEMBER_QUOTA_EXCEEDED = 'MEMBER_QUOTA_EXCEEDED',@@ -348,14 +353,18 @@ export enum ErrorNames {SUBSCRIPTION_ALREADY_EXISTS = 'SUBSCRIPTION_ALREADY_EXISTS',SUBSCRIPTION_EXPIRED = 'SUBSCRIPTION_EXPIRED',SUBSCRIPTION_HAS_BEEN_CANCELED = 'SUBSCRIPTION_HAS_BEEN_CANCELED',+ SUBSCRIPTION_HAS_NOT_BEEN_CANCELED = 'SUBSCRIPTION_HAS_NOT_BEEN_CANCELED',SUBSCRIPTION_NOT_EXISTS = 'SUBSCRIPTION_NOT_EXISTS',SUBSCRIPTION_PLAN_NOT_FOUND = 'SUBSCRIPTION_PLAN_NOT_FOUND',TOO_MANY_REQUEST = 'TOO_MANY_REQUEST',UNKNOWN_OAUTH_PROVIDER = 'UNKNOWN_OAUTH_PROVIDER',UNSPLASH_IS_NOT_CONFIGURED = 'UNSPLASH_IS_NOT_CONFIGURED',+ UNSUPPORTED_SUBSCRIPTION_PLAN = 'UNSUPPORTED_SUBSCRIPTION_PLAN',USER_AVATAR_NOT_FOUND = 'USER_AVATAR_NOT_FOUND',USER_NOT_FOUND = 'USER_NOT_FOUND',VERSION_REJECTED = 'VERSION_REJECTED',+ WORKSPACE_ID_REQUIRED_FOR_TEAM_SUBSCRIPTION = 'WORKSPACE_ID_REQUIRED_FOR_TEAM_SUBSCRIPTION',+ WORKSPACE_ID_REQUIRED_TO_UPDATE_TEAM_SUBSCRIPTION = 'WORKSPACE_ID_REQUIRED_TO_UPDATE_TEAM_SUBSCRIPTION',WRONG_SIGN_IN_CREDENTIALS = 'WRONG_SIGN_IN_CREDENTIALS',WRONG_SIGN_IN_METHOD = 'WRONG_SIGN_IN_METHOD',}@@ -491,15 +500,15 @@ export interface LimitedUserType {}export interface ListUserInput {- first: InputMaybe<Scalars['Int']['input']>;- skip: InputMaybe<Scalars['Int']['input']>;+ first?: InputMaybe<Scalars['Int']['input']>;+ skip?: InputMaybe<Scalars['Int']['input']>;}export interface ManageUserInput {/** User email */- email: InputMaybe<Scalars['String']['input']>;+ email?: InputMaybe<Scalars['String']['input']>;/** User name */- name: InputMaybe<Scalars['String']['input']>;+ name?: InputMaybe<Scalars['String']['input']>;}export interface MissingOauthQueryParameterDataType {@@ -581,7 +590,7 @@ export interface Mutation {export interface MutationAcceptInviteByIdArgs {inviteId: Scalars['String']['input'];- sendAcceptMail: InputMaybe<Scalars['Boolean']['input']>;+ sendAcceptMail?: InputMaybe<Scalars['Boolean']['input']>;workspaceId: Scalars['String']['input'];}@@ -591,8 +600,9 @@ export interface MutationAddWorkspaceFeatureArgs {}export interface MutationCancelSubscriptionArgs {- idempotencyKey: InputMaybe<Scalars['String']['input']>;+ idempotencyKey?: InputMaybe<Scalars['String']['input']>;plan?: InputMaybe<SubscriptionPlan>;+ workspaceId?: InputMaybe<Scalars['String']['input']>;}export interface MutationChangeEmailArgs {@@ -603,7 +613,7 @@ export interface MutationChangeEmailArgs {export interface MutationChangePasswordArgs {newPassword: Scalars['String']['input'];token: Scalars['String']['input'];- userId: InputMaybe<Scalars['String']['input']>;+ userId?: InputMaybe<Scalars['String']['input']>;}export interface MutationCleanupCopilotSessionArgs {@@ -636,7 +646,7 @@ export interface MutationCreateUserArgs {}export interface MutationCreateWorkspaceArgs {- init: InputMaybe<Scalars['Upload']['input']>;+ init?: InputMaybe<Scalars['Upload']['input']>;}export interface MutationDeleteBlobArgs {@@ -659,12 +669,12 @@ export interface MutationForkCopilotSessionArgs {export interface MutationInviteArgs {email: Scalars['String']['input'];permission: Permission;- sendInviteMail: InputMaybe<Scalars['Boolean']['input']>;+ sendInviteMail?: InputMaybe<Scalars['Boolean']['input']>;workspaceId: Scalars['String']['input'];}export interface MutationLeaveWorkspaceArgs {- sendLeaveMail: InputMaybe<Scalars['Boolean']['input']>;+ sendLeaveMail?: InputMaybe<Scalars['Boolean']['input']>;workspaceId: Scalars['String']['input'];workspaceName: Scalars['String']['input'];}@@ -687,8 +697,9 @@ export interface MutationRemoveWorkspaceFeatureArgs {}export interface MutationResumeSubscriptionArgs {- idempotencyKey: InputMaybe<Scalars['String']['input']>;+ idempotencyKey?: InputMaybe<Scalars['String']['input']>;plan?: InputMaybe<SubscriptionPlan>;+ workspaceId?: InputMaybe<Scalars['String']['input']>;}export interface MutationRevokeArgs {@@ -708,17 +719,17 @@ export interface MutationRevokePublicPageArgs {export interface MutationSendChangeEmailArgs {callbackUrl: Scalars['String']['input'];- email: InputMaybe<Scalars['String']['input']>;+ email?: InputMaybe<Scalars['String']['input']>;}export interface MutationSendChangePasswordEmailArgs {callbackUrl: Scalars['String']['input'];- email: InputMaybe<Scalars['String']['input']>;+ email?: InputMaybe<Scalars['String']['input']>;}export interface MutationSendSetPasswordEmailArgs {callbackUrl: Scalars['String']['input'];- email: InputMaybe<Scalars['String']['input']>;+ email?: InputMaybe<Scalars['String']['input']>;}export interface MutationSendVerifyChangeEmailArgs {@@ -766,9 +777,10 @@ export interface MutationUpdateRuntimeConfigsArgs {}export interface MutationUpdateSubscriptionRecurringArgs {- idempotencyKey: InputMaybe<Scalars['String']['input']>;+ idempotencyKey?: InputMaybe<Scalars['String']['input']>;plan?: InputMaybe<SubscriptionPlan>;recurring: SubscriptionRecurring;+ workspaceId?: InputMaybe<Scalars['String']['input']>;}export interface MutationUpdateUserArgs {@@ -845,7 +857,6 @@ export interface Query {/** List all copilot prompts */listCopilotPrompts: Array<CopilotPromptType>;listWorkspaceFeatures: Array<WorkspaceType>;- /** @deprecated use `userPrices` instead */prices: Array<SubscriptionPrice>;/** server config */serverConfig: ServerConfigType;@@ -914,13 +925,13 @@ export interface QueryWorkspaceArgs {}export interface QueryChatHistoriesInput {- action: InputMaybe<Scalars['Boolean']['input']>;- fork: InputMaybe<Scalars['Boolean']['input']>;- limit: InputMaybe<Scalars['Int']['input']>;- messageOrder: InputMaybe<ChatHistoryOrder>;- sessionId: InputMaybe<Scalars['String']['input']>;- sessionOrder: InputMaybe<ChatHistoryOrder>;- skip: InputMaybe<Scalars['Int']['input']>;+ action?: InputMaybe<Scalars['Boolean']['input']>;+ fork?: InputMaybe<Scalars['Boolean']['input']>;+ limit?: InputMaybe<Scalars['Int']['input']>;+ messageOrder?: InputMaybe<ChatHistoryOrder>;+ sessionId?: InputMaybe<Scalars['String']['input']>;+ sessionOrder?: InputMaybe<ChatHistoryOrder>;+ skip?: InputMaybe<Scalars['Int']['input']>;}export interface QuotaQueryType {@@ -1123,17 +1134,22 @@ export interface UnknownOauthProviderDataType {name: Scalars['String']['output'];}+export interface UnsupportedSubscriptionPlanDataType {+ __typename?: 'UnsupportedSubscriptionPlanDataType';+ plan: Scalars['String']['output'];+}+export interface UpdateUserInput {/** User name */- name: InputMaybe<Scalars['String']['input']>;+ name?: InputMaybe<Scalars['String']['input']>;}export interface UpdateWorkspaceInput {/** Enable url previous when sharing */- enableUrlPreview: InputMaybe<Scalars['Boolean']['input']>;+ enableUrlPreview?: InputMaybe<Scalars['Boolean']['input']>;id: Scalars['ID']['input'];/** is Public workspace */- public: InputMaybe<Scalars['Boolean']['input']>;+ public?: InputMaybe<Scalars['Boolean']['input']>;}export type UserOrLimitedUser = LimitedUserType | UserType;@@ -1188,11 +1204,11 @@ export interface UserType {}export interface UserTypeCopilotArgs {- workspaceId: InputMaybe<Scalars['String']['input']>;+ workspaceId?: InputMaybe<Scalars['String']['input']>;}export interface UserTypeInvoicesArgs {- skip: InputMaybe<Scalars['Int']['input']>;+ skip?: InputMaybe<Scalars['Int']['input']>;take?: InputMaybe<Scalars['Int']['input']>;}@@ -1264,17 +1280,19 @@ export interface WorkspaceType {* @deprecated use WorkspaceType.publicPages*/sharedPages: Array<Scalars['String']['output']>;+ /** The team subscription of the workspace, if exists. */+ subscription: Maybe<SubscriptionType>;}export interface WorkspaceTypeHistoriesArgs {- before: InputMaybe<Scalars['DateTime']['input']>;+ before?: InputMaybe<Scalars['DateTime']['input']>;guid: Scalars['String']['input'];- take: InputMaybe<Scalars['Int']['input']>;+ take?: InputMaybe<Scalars['Int']['input']>;}export interface WorkspaceTypeMembersArgs {- skip: InputMaybe<Scalars['Int']['input']>;- take: InputMaybe<Scalars['Int']['input']>;+ skip?: InputMaybe<Scalars['Int']['input']>;+ take?: InputMaybe<Scalars['Int']['input']>;}export interface WorkspaceTypePageMetaArgs {@@ -1519,8 +1537,8 @@ export type PasswordLimitsFragment = {export type GetCopilotHistoriesQueryVariables = Exact<{workspaceId: Scalars['String']['input'];- docId: InputMaybe<Scalars['String']['input']>;- options: InputMaybe<QueryChatHistoriesInput>;+ docId?: InputMaybe<Scalars['String']['input']>;+ options?: InputMaybe<QueryChatHistoriesInput>;}>;export type GetCopilotHistoriesQuery = {@@ -1550,8 +1568,8 @@ export type GetCopilotHistoriesQuery = {export type GetCopilotHistoryIdsQueryVariables = Exact<{workspaceId: Scalars['String']['input'];- docId: InputMaybe<Scalars['String']['input']>;- options: InputMaybe<QueryChatHistoriesInput>;+ docId?: InputMaybe<Scalars['String']['input']>;+ options?: InputMaybe<QueryChatHistoriesInput>;}>;export type GetCopilotHistoryIdsQuery = {@@ -1921,8 +1939,8 @@ export type GetWorkspacesQuery = {export type ListHistoryQueryVariables = Exact<{workspaceId: Scalars['String']['input'];pageDocId: Scalars['String']['input'];- take: InputMaybe<Scalars['Int']['input']>;- before: InputMaybe<Scalars['DateTime']['input']>;+ take?: InputMaybe<Scalars['Int']['input']>;+ before?: InputMaybe<Scalars['DateTime']['input']>;}>;export type ListHistoryQuery = {@@ -1976,7 +1994,7 @@ export type InvoicesQuery = {export type LeaveWorkspaceMutationVariables = Exact<{workspaceId: Scalars['String']['input'];workspaceName: Scalars['String']['input'];- sendLeaveMail: InputMaybe<Scalars['Boolean']['input']>;+ sendLeaveMail?: InputMaybe<Scalars['Boolean']['input']>;}>;export type LeaveWorkspaceMutation = {@@ -2428,7 +2446,7 @@ export type InviteByEmailMutationVariables = Exact<{workspaceId: Scalars['String']['input'];email: Scalars['String']['input'];permission: Permission;- sendInviteMail: InputMaybe<Scalars['Boolean']['input']>;+ sendInviteMail?: InputMaybe<Scalars['Boolean']['input']>;}>;export type InviteByEmailMutation = { __typename?: 'Mutation'; invite: string };@@ -2436,7 +2454,7 @@ export type InviteByEmailMutation = { __typename?: 'Mutation'; invite: string };export type AcceptInviteByInviteIdMutationVariables = Exact<{workspaceId: Scalars['String']['input'];inviteId: Scalars['String']['input'];- sendAcceptMail: InputMaybe<Scalars['Boolean']['input']>;+ sendAcceptMail?: InputMaybe<Scalars['Boolean']['input']>;}>;export type AcceptInviteByInviteIdMutation = {