feat: wip server folder structure (#4573)

* feat: wip server folder structure

* fix: merge

* fix: wrong merge

* fix: remove unused file

* fix: comment

* fix: lint

* fix: merge

* fix: remove console.log

* fix: metadata graphql arguments broken

packages/twenty-server/src/engine/core-modules/billing/billing.controller.ts

@@ -0,0 +1,68 @@
+import {
+  Controller,
+  Headers,
+  Req,
+  RawBodyRequest,
+  Logger,
+  Post,
+  Res,
+} from '@nestjs/common';
+
+import { Response } from 'express';
+
+import {
+  BillingService,
+  WebhookEvent,
+} from 'src/engine/core-modules/billing/billing.service';
+import { StripeService } from 'src/engine/core-modules/billing/stripe/stripe.service';
+
+@Controller('billing')
+export class BillingController {
+  protected readonly logger = new Logger(BillingController.name);
+
+  constructor(
+    private readonly stripeService: StripeService,
+    private readonly billingService: BillingService,
+  ) {}
+
+  @Post('/webhooks')
+  async handleWebhooks(
+    @Headers('stripe-signature') signature: string,
+    @Req() req: RawBodyRequest<Request>,
+    @Res() res: Response,
+  ) {
+    if (!req.rawBody) {
+      res.status(400).end();
+
+      return;
+    }
+    const event = this.stripeService.constructEventFromPayload(
+      signature,
+      req.rawBody,
+    );
+
+    if (event.type === WebhookEvent.SETUP_INTENT_SUCCEEDED) {
+      await this.billingService.handleUnpaidInvoices(event.data);
+    }
+
+    if (
+      event.type === WebhookEvent.CUSTOMER_SUBSCRIPTION_CREATED ||
+      event.type === WebhookEvent.CUSTOMER_SUBSCRIPTION_UPDATED ||
+      event.type === WebhookEvent.CUSTOMER_SUBSCRIPTION_DELETED
+    ) {
+      const workspaceId = event.data.object.metadata?.workspaceId;
+
+      if (!workspaceId) {
+        res.status(404).end();
+
+        return;
+      }
+
+      await this.billingService.upsertBillingSubscription(
+        workspaceId,
+        event.data,
+      );
+    }
+    res.status(200).end();
+  }
+}

packages/twenty-server/src/engine/core-modules/billing/billing.module.ts

@@ -0,0 +1,27 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { BillingController } from 'src/engine/core-modules/billing/billing.controller';
+import { BillingService } from 'src/engine/core-modules/billing/billing.service';
+import { StripeModule } from 'src/engine/core-modules/billing/stripe/stripe.module';
+import { BillingSubscription } from 'src/engine/core-modules/billing/entities/billing-subscription.entity';
+import { BillingSubscriptionItem } from 'src/engine/core-modules/billing/entities/billing-subscription-item.entity';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { BillingResolver } from 'src/engine/core-modules/billing/billing.resolver';
+import { BillingWorkspaceMemberListener } from 'src/engine/core-modules/billing/listeners/billing-workspace-member.listener';
+import { UserWorkspaceModule } from 'src/engine/core-modules/user-workspace/user-workspace.module';
+
+@Module({
+  imports: [
+    StripeModule,
+    UserWorkspaceModule,
+    TypeOrmModule.forFeature(
+      [BillingSubscription, BillingSubscriptionItem, Workspace],
+      'core',
+    ),
+  ],
+  controllers: [BillingController],
+  providers: [BillingService, BillingResolver, BillingWorkspaceMemberListener],
+  exports: [BillingService],
+})
+export class BillingModule {}

packages/twenty-server/src/engine/core-modules/billing/billing.resolver.ts

@@ -0,0 +1,91 @@
+import { Args, Mutation, Query, Resolver } from '@nestjs/graphql';
+import { UseGuards } from '@nestjs/common';
+
+import {
+  AvailableProduct,
+  BillingService,
+} from 'src/engine/core-modules/billing/billing.service';
+import { ProductInput } from 'src/engine/core-modules/billing/dto/product.input';
+import { assert } from 'src/utils/assert';
+import { ProductPricesEntity } from 'src/engine/core-modules/billing/dto/product-prices.entity';
+import { JwtAuthGuard } from 'src/engine/guards/jwt.auth.guard';
+import { AuthUser } from 'src/engine/decorators/auth/auth-user.decorator';
+import { User } from 'src/engine/core-modules/user/user.entity';
+import { CheckoutSessionInput } from 'src/engine/core-modules/billing/dto/checkout-session.input';
+import { SessionEntity } from 'src/engine/core-modules/billing/dto/session.entity';
+import { BillingSessionInput } from 'src/engine/core-modules/billing/dto/billing-session.input';
+
+@Resolver()
+export class BillingResolver {
+  constructor(private readonly billingService: BillingService) {}
+
+  @Query(() => ProductPricesEntity)
+  async getProductPrices(@Args() { product }: ProductInput) {
+    const stripeProductId = this.billingService.getProductStripeId(product);
+
+    assert(
+      stripeProductId,
+      `Product '${product}' not found, available products are ['${Object.values(
+        AvailableProduct,
+      ).join("','")}']`,
+    );
+
+    const productPrices =
+      await this.billingService.getProductPrices(stripeProductId);
+
+    return {
+      totalNumberOfPrices: productPrices.length,
+      productPrices: productPrices,
+    };
+  }
+
+  @Query(() => SessionEntity)
+  @UseGuards(JwtAuthGuard)
+  async billingPortalSession(
+    @AuthUser() user: User,
+    @Args() { returnUrlPath }: BillingSessionInput,
+  ) {
+    return {
+      url: await this.billingService.computeBillingPortalSessionURL(
+        user.defaultWorkspaceId,
+        returnUrlPath,
+      ),
+    };
+  }
+
+  @Mutation(() => SessionEntity)
+  @UseGuards(JwtAuthGuard)
+  async checkoutSession(
+    @AuthUser() user: User,
+    @Args() { recurringInterval, successUrlPath }: CheckoutSessionInput,
+  ) {
+    const stripeProductId = this.billingService.getProductStripeId(
+      AvailableProduct.BasePlan,
+    );
+
+    assert(
+      stripeProductId,
+      'BasePlan productId not found, please check your BILLING_STRIPE_BASE_PLAN_PRODUCT_ID env variable',
+    );
+
+    const productPrices =
+      await this.billingService.getProductPrices(stripeProductId);
+
+    const stripePriceId = productPrices.filter(
+      (price) => price.recurringInterval === recurringInterval,
+    )?.[0]?.stripePriceId;
+
+    assert(
+      stripePriceId,
+      `BasePlan priceId not found, please check body.recurringInterval and product '${AvailableProduct.BasePlan}' prices`,
+    );
+
+    return {
+      url: await this.billingService.computeCheckoutSessionURL(
+        user,
+        stripePriceId,
+        successUrlPath,
+      ),
+    };
+  }
+}

packages/twenty-server/src/engine/core-modules/billing/billing.service.ts

@@ -0,0 +1,268 @@
+import { Injectable, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+
+import Stripe from 'stripe';
+import { Not, Repository } from 'typeorm';
+
+import { EnvironmentService } from 'src/engine/integrations/environment/environment.service';
+import { StripeService } from 'src/engine/core-modules/billing/stripe/stripe.service';
+import { BillingSubscription } from 'src/engine/core-modules/billing/entities/billing-subscription.entity';
+import { BillingSubscriptionItem } from 'src/engine/core-modules/billing/entities/billing-subscription-item.entity';
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { ProductPriceEntity } from 'src/engine/core-modules/billing/dto/product-price.entity';
+import { User } from 'src/engine/core-modules/user/user.entity';
+import { assert } from 'src/utils/assert';
+import { UserWorkspaceService } from 'src/engine/core-modules/user-workspace/user-workspace.service';
+
+export enum AvailableProduct {
+  BasePlan = 'base-plan',
+}
+
+export enum WebhookEvent {
+  CUSTOMER_SUBSCRIPTION_CREATED = 'customer.subscription.created',
+  CUSTOMER_SUBSCRIPTION_UPDATED = 'customer.subscription.updated',
+  CUSTOMER_SUBSCRIPTION_DELETED = 'customer.subscription.deleted',
+  SETUP_INTENT_SUCCEEDED = 'setup_intent.succeeded',
+}
+
+@Injectable()
+export class BillingService {
+  protected readonly logger = new Logger(BillingService.name);
+  constructor(
+    private readonly stripeService: StripeService,
+    private readonly userWorkspaceService: UserWorkspaceService,
+    private readonly environmentService: EnvironmentService,
+    @InjectRepository(BillingSubscription, 'core')
+    private readonly billingSubscriptionRepository: Repository<BillingSubscription>,
+    @InjectRepository(BillingSubscriptionItem, 'core')
+    private readonly billingSubscriptionItemRepository: Repository<BillingSubscriptionItem>,
+    @InjectRepository(Workspace, 'core')
+    private readonly workspaceRepository: Repository<Workspace>,
+  ) {}
+
+  getProductStripeId(product: AvailableProduct) {
+    if (product === AvailableProduct.BasePlan) {
+      return this.environmentService.get('BILLING_STRIPE_BASE_PLAN_PRODUCT_ID');
+    }
+  }
+
+  async getProductPrices(stripeProductId: string) {
+    const productPrices =
+      await this.stripeService.getProductPrices(stripeProductId);
+
+    return this.formatProductPrices(productPrices.data);
+  }
+
+  formatProductPrices(prices: Stripe.Price[]) {
+    const result: Record<string, ProductPriceEntity> = {};
+
+    prices.forEach((item) => {
+      const interval = item.recurring?.interval;
+
+      if (!interval || !item.unit_amount) {
+        return;
+      }
+      if (
+        !result[interval] ||
+        item.created > (result[interval]?.created || 0)
+      ) {
+        result[interval] = {
+          unitAmount: item.unit_amount,
+          recurringInterval: interval,
+          created: item.created,
+          stripePriceId: item.id,
+        };
+      }
+    });
+
+    return Object.values(result).sort((a, b) => a.unitAmount - b.unitAmount);
+  }
+
+  async getCurrentBillingSubscription(criteria: {
+    workspaceId?: string;
+    stripeCustomerId?: string;
+  }) {
+    const notCanceledSubscriptions =
+      await this.billingSubscriptionRepository.find({
+        where: { ...criteria, status: Not('canceled') },
+        relations: ['billingSubscriptionItems'],
+      });
+
+    assert(
+      notCanceledSubscriptions.length <= 1,
+      `More than on not canceled subscription for workspace ${criteria.workspaceId}`,
+    );
+
+    return notCanceledSubscriptions?.[0];
+  }
+
+  async getBillingSubscriptionItem(
+    workspaceId: string,
+    stripeProductId = this.environmentService.get(
+      'BILLING_STRIPE_BASE_PLAN_PRODUCT_ID',
+    ),
+  ) {
+    const billingSubscription = await this.getCurrentBillingSubscription({
+      workspaceId,
+    });
+
+    if (!billingSubscription) {
+      throw new Error(
+        `Cannot find billingSubscriptionItem for product ${stripeProductId} for workspace ${workspaceId}`,
+      );
+    }
+
+    const billingSubscriptionItem =
+      billingSubscription.billingSubscriptionItems.filter(
+        (billingSubscriptionItem) =>
+          billingSubscriptionItem.stripeProductId === stripeProductId,
+      )?.[0];
+
+    if (!billingSubscriptionItem) {
+      throw new Error(
+        `Cannot find billingSubscriptionItem for product ${stripeProductId} for workspace ${workspaceId}`,
+      );
+    }
+
+    return billingSubscriptionItem;
+  }
+
+  async computeBillingPortalSessionURL(
+    workspaceId: string,
+    returnUrlPath?: string,
+  ) {
+    const billingSubscription = await this.getCurrentBillingSubscription({
+      workspaceId,
+    });
+
+    if (!billingSubscription) {
+      return;
+    }
+
+    const frontBaseUrl = this.environmentService.get('FRONT_BASE_URL');
+    const returnUrl = returnUrlPath
+      ? frontBaseUrl + returnUrlPath
+      : frontBaseUrl;
+
+    const session = await this.stripeService.createBillingPortalSession(
+      billingSubscription.stripeCustomerId,
+      returnUrl,
+    );
+
+    assert(session.url, 'Error: missing billingPortal.session.url');
+
+    return session.url;
+  }
+
+  async computeCheckoutSessionURL(
+    user: User,
+    priceId: string,
+    successUrlPath?: string,
+  ): Promise<string> {
+    const frontBaseUrl = this.environmentService.get('FRONT_BASE_URL');
+    const successUrl = successUrlPath
+      ? frontBaseUrl + successUrlPath
+      : frontBaseUrl;
+
+    let quantity = 1;
+
+    const stripeCustomerId = (
+      await this.billingSubscriptionRepository.findOneBy({
+        workspaceId: user.defaultWorkspaceId,
+      })
+    )?.stripeCustomerId;
+
+    try {
+      quantity = await this.userWorkspaceService.getWorkspaceMemberCount(
+        user.defaultWorkspaceId,
+      );
+    } catch (e) {}
+
+    const session = await this.stripeService.createCheckoutSession(
+      user,
+      priceId,
+      quantity,
+      successUrl,
+      frontBaseUrl,
+      stripeCustomerId,
+    );
+
+    assert(session.url, 'Error: missing checkout.session.url');
+
+    return session.url;
+  }
+
+  async deleteSubscription(workspaceId: string) {
+    const subscriptionToCancel = await this.getCurrentBillingSubscription({
+      workspaceId,
+    });
+
+    if (subscriptionToCancel) {
+      await this.stripeService.cancelSubscription(
+        subscriptionToCancel.stripeSubscriptionId,
+      );
+      await this.billingSubscriptionRepository.delete(subscriptionToCancel.id);
+    }
+  }
+
+  async handleUnpaidInvoices(data: Stripe.SetupIntentSucceededEvent.Data) {
+    const billingSubscription = await this.getCurrentBillingSubscription({
+      stripeCustomerId: data.object.customer as string,
+    });
+
+    if (billingSubscription?.status === 'unpaid') {
+      await this.stripeService.collectLastInvoice(
+        billingSubscription.stripeSubscriptionId,
+      );
+    }
+  }
+
+  async upsertBillingSubscription(
+    workspaceId: string,
+    data:
+      | Stripe.CustomerSubscriptionUpdatedEvent.Data
+      | Stripe.CustomerSubscriptionCreatedEvent.Data
+      | Stripe.CustomerSubscriptionDeletedEvent.Data,
+  ) {
+    await this.billingSubscriptionRepository.upsert(
+      {
+        workspaceId: workspaceId,
+        stripeCustomerId: data.object.customer as string,
+        stripeSubscriptionId: data.object.id,
+        status: data.object.status,
+      },
+      {
+        conflictPaths: ['stripeSubscriptionId'],
+        skipUpdateIfNoValuesChanged: true,
+      },
+    );
+
+    await this.workspaceRepository.update(workspaceId, {
+      subscriptionStatus: data.object.status,
+    });
+
+    const billingSubscription = await this.getCurrentBillingSubscription({
+      workspaceId,
+    });
+
+    if (!billingSubscription) {
+      return;
+    }
+
+    await this.billingSubscriptionItemRepository.upsert(
+      data.object.items.data.map((item) => {
+        return {
+          billingSubscriptionId: billingSubscription.id,
+          stripeProductId: item.price.product as string,
+          stripePriceId: item.price.id,
+          stripeSubscriptionItemId: item.id,
+          quantity: item.quantity,
+        };
+      }),
+      {
+        conflictPaths: ['billingSubscriptionId', 'stripeProductId'],
+        skipUpdateIfNoValuesChanged: true,
+      },
+    );
+  }
+}

packages/twenty-server/src/engine/core-modules/billing/dto/billing-session.input.ts

@@ -0,0 +1,11 @@
+import { ArgsType, Field } from '@nestjs/graphql';
+
+import { IsOptional, IsString } from 'class-validator';
+
+@ArgsType()
+export class BillingSessionInput {
+  @Field(() => String, { nullable: true })
+  @IsString()
+  @IsOptional()
+  returnUrlPath?: string;
+}

packages/twenty-server/src/engine/core-modules/billing/dto/checkout-session.input.ts

@@ -0,0 +1,17 @@
+import { ArgsType, Field } from '@nestjs/graphql';
+
+import { IsNotEmpty, IsOptional, IsString } from 'class-validator';
+import Stripe from 'stripe';
+
+@ArgsType()
+export class CheckoutSessionInput {
+  @Field(() => String)
+  @IsString()
+  @IsNotEmpty()
+  recurringInterval: Stripe.Price.Recurring.Interval;
+
+  @Field(() => String, { nullable: true })
+  @IsString()
+  @IsOptional()
+  successUrlPath?: string;
+}

packages/twenty-server/src/engine/core-modules/billing/dto/product-price.entity.ts

@@ -0,0 +1,18 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+
+import Stripe from 'stripe';
+
+@ObjectType()
+export class ProductPriceEntity {
+  @Field(() => String)
+  recurringInterval: Stripe.Price.Recurring.Interval;
+
+  @Field(() => Number)
+  unitAmount: number;
+
+  @Field(() => Number)
+  created: number;
+
+  @Field(() => String)
+  stripePriceId: string;
+}

packages/twenty-server/src/engine/core-modules/billing/dto/product-prices.entity.ts

@@ -0,0 +1,12 @@
+import { Field, Int, ObjectType } from '@nestjs/graphql';
+
+import { ProductPriceEntity } from 'src/engine/core-modules/billing/dto/product-price.entity';
+
+@ObjectType()
+export class ProductPricesEntity {
+  @Field(() => Int)
+  totalNumberOfPrices: number;
+
+  @Field(() => [ProductPriceEntity])
+  productPrices: ProductPriceEntity[];
+}

packages/twenty-server/src/engine/core-modules/billing/dto/product.input.ts

@@ -0,0 +1,13 @@
+import { ArgsType, Field } from '@nestjs/graphql';
+
+import { IsNotEmpty, IsString } from 'class-validator';
+
+import { AvailableProduct } from 'src/engine/core-modules/billing/billing.service';
+
+@ArgsType()
+export class ProductInput {
+  @Field(() => String)
+  @IsString()
+  @IsNotEmpty()
+  product: AvailableProduct;
+}

packages/twenty-server/src/engine/core-modules/billing/dto/session.entity.ts

@@ -0,0 +1,7 @@
+import { Field, ObjectType } from '@nestjs/graphql';
+
+@ObjectType()
+export class SessionEntity {
+  @Field(() => String, { nullable: true })
+  url: string;
+}

packages/twenty-server/src/engine/core-modules/billing/entities/billing-subscription-item.entity.ts

@@ -0,0 +1,58 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  ManyToOne,
+  PrimaryGeneratedColumn,
+  Unique,
+  UpdateDateColumn,
+} from 'typeorm';
+
+import { BillingSubscription } from 'src/engine/core-modules/billing/entities/billing-subscription.entity';
+
+@Entity({ name: 'billingSubscriptionItem', schema: 'core' })
+@Unique('IndexOnBillingSubscriptionIdAndStripeProductIdUnique', [
+  'billingSubscriptionId',
+  'stripeProductId',
+])
+@Unique('IndexOnBillingSubscriptionIdAndStripeSubscriptionItemIdUnique', [
+  'billingSubscriptionId',
+  'stripeSubscriptionItemId',
+])
+export class BillingSubscriptionItem {
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ nullable: true })
+  deletedAt?: Date;
+
+  @CreateDateColumn({ type: 'timestamp with time zone' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ type: 'timestamp with time zone' })
+  updatedAt: Date;
+
+  @Column({ nullable: false })
+  billingSubscriptionId: string;
+
+  @ManyToOne(
+    () => BillingSubscription,
+    (billingSubscription) => billingSubscription.billingSubscriptionItems,
+    {
+      onDelete: 'CASCADE',
+    },
+  )
+  billingSubscription: BillingSubscription;
+
+  @Column({ nullable: false })
+  stripeProductId: string;
+
+  @Column({ nullable: false })
+  stripePriceId: string;
+
+  @Column({ nullable: false })
+  stripeSubscriptionItemId: string;
+
+  @Column({ nullable: false })
+  quantity: number;
+}

packages/twenty-server/src/engine/core-modules/billing/entities/billing-subscription.entity.ts

@@ -0,0 +1,59 @@
+import { Field, ID, ObjectType } from '@nestjs/graphql';
+
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  JoinColumn,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from 'typeorm';
+import Stripe from 'stripe';
+import { IDField } from '@ptc-org/nestjs-query-graphql';
+
+import { Workspace } from 'src/engine/core-modules/workspace/workspace.entity';
+import { BillingSubscriptionItem } from 'src/engine/core-modules/billing/entities/billing-subscription-item.entity';
+
+@Entity({ name: 'billingSubscription', schema: 'core' })
+@ObjectType('BillingSubscription')
+export class BillingSubscription {
+  @IDField(() => ID)
+  @PrimaryGeneratedColumn('uuid')
+  id: string;
+
+  @Column({ nullable: true })
+  deletedAt?: Date;
+
+  @CreateDateColumn({ type: 'timestamp with time zone' })
+  createdAt: Date;
+
+  @UpdateDateColumn({ type: 'timestamp with time zone' })
+  updatedAt: Date;
+
+  @ManyToOne(() => Workspace, (workspace) => workspace.billingSubscriptions, {
+    onDelete: 'CASCADE',
+  })
+  @JoinColumn()
+  workspace: Workspace;
+
+  @Column({ nullable: false, type: 'uuid' })
+  workspaceId: string;
+
+  @Column({ nullable: false })
+  stripeCustomerId: string;
+
+  @Column({ unique: true, nullable: false })
+  stripeSubscriptionId: string;
+
+  @Field()
+  @Column({ nullable: false })
+  status: Stripe.Subscription.Status;
+
+  @OneToMany(
+    () => BillingSubscriptionItem,
+    (billingSubscriptionItem) => billingSubscriptionItem.billingSubscription,
+  )
+  billingSubscriptionItems: BillingSubscriptionItem[];
+}

packages/twenty-server/src/engine/core-modules/billing/jobs/update-subscription.job.ts

@@ -0,0 +1,46 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import { MessageQueueJob } from 'src/engine/integrations/message-queue/interfaces/message-queue-job.interface';
+
+import { BillingService } from 'src/engine/core-modules/billing/billing.service';
+import { UserWorkspaceService } from 'src/engine/core-modules/user-workspace/user-workspace.service';
+import { StripeService } from 'src/engine/core-modules/billing/stripe/stripe.service';
+export type UpdateSubscriptionJobData = { workspaceId: string };
+@Injectable()
+export class UpdateSubscriptionJob
+  implements MessageQueueJob<UpdateSubscriptionJobData>
+{
+  protected readonly logger = new Logger(UpdateSubscriptionJob.name);
+  constructor(
+    private readonly billingService: BillingService,
+    private readonly userWorkspaceService: UserWorkspaceService,
+    private readonly stripeService: StripeService,
+  ) {}
+
+  async handle(data: UpdateSubscriptionJobData): Promise<void> {
+    const workspaceMembersCount =
+      await this.userWorkspaceService.getWorkspaceMemberCount(data.workspaceId);
+
+    if (workspaceMembersCount <= 0) {
+      return;
+    }
+
+    try {
+      const billingSubscriptionItem =
+        await this.billingService.getBillingSubscriptionItem(data.workspaceId);
+
+      await this.stripeService.updateSubscriptionItem(
+        billingSubscriptionItem.stripeSubscriptionItemId,
+        workspaceMembersCount,
+      );
+
+      this.logger.log(
+        `Updating workspace ${data.workspaceId} subscription quantity to ${workspaceMembersCount} members`,
+      );
+    } catch (e) {
+      this.logger.warn(
+        `Failed to update workspace ${data.workspaceId} subscription quantity to ${workspaceMembersCount} members. Error: ${e}`,
+      );
+    }
+  }
+}

packages/twenty-server/src/engine/core-modules/billing/listeners/billing-workspace-member.listener.ts

@@ -0,0 +1,30 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { OnEvent } from '@nestjs/event-emitter';
+
+import { MessageQueue } from 'src/engine/integrations/message-queue/message-queue.constants';
+import { MessageQueueService } from 'src/engine/integrations/message-queue/services/message-queue.service';
+import { ObjectRecordCreateEvent } from 'src/engine/integrations/event-emitter/types/object-record-create.event';
+import { WorkspaceMemberObjectMetadata } from 'src/modules/workspace-member/standard-objects/workspace-member.object-metadata';
+import {
+  UpdateSubscriptionJob,
+  UpdateSubscriptionJobData,
+} from 'src/engine/core-modules/billing/jobs/update-subscription.job';
+
+@Injectable()
+export class BillingWorkspaceMemberListener {
+  constructor(
+    @Inject(MessageQueue.billingQueue)
+    private readonly messageQueueService: MessageQueueService,
+  ) {}
+
+  @OnEvent('workspaceMember.created')
+  @OnEvent('workspaceMember.deleted')
+  async handleCreateOrDeleteEvent(
+    payload: ObjectRecordCreateEvent<WorkspaceMemberObjectMetadata>,
+  ) {
+    await this.messageQueueService.add<UpdateSubscriptionJobData>(
+      UpdateSubscriptionJob.name,
+      { workspaceId: payload.workspaceId },
+    );
+  }
+}

packages/twenty-server/src/engine/core-modules/billing/stripe/stripe.module.ts

@@ -0,0 +1,9 @@
+import { Module } from '@nestjs/common';
+
+import { StripeService } from 'src/engine/core-modules/billing/stripe/stripe.service';
+
+@Module({
+  providers: [StripeService],
+  exports: [StripeService],
+})
+export class StripeModule {}

packages/twenty-server/src/engine/core-modules/billing/stripe/stripe.service.ts

@@ -0,0 +1,108 @@
+import { Injectable, Logger } from '@nestjs/common';
+
+import Stripe from 'stripe';
+
+import { EnvironmentService } from 'src/engine/integrations/environment/environment.service';
+import { User } from 'src/engine/core-modules/user/user.entity';
+
+@Injectable()
+export class StripeService {
+  protected readonly logger = new Logger(StripeService.name);
+  private readonly stripe: Stripe;
+
+  constructor(private readonly environmentService: EnvironmentService) {
+    this.stripe = new Stripe(
+      this.environmentService.get('BILLING_STRIPE_API_KEY'),
+      {},
+    );
+  }
+
+  constructEventFromPayload(signature: string, payload: Buffer) {
+    const webhookSecret = this.environmentService.get(
+      'BILLING_STRIPE_WEBHOOK_SECRET',
+    );
+
+    return this.stripe.webhooks.constructEvent(
+      payload,
+      signature,
+      webhookSecret,
+    );
+  }
+
+  async getProductPrices(stripeProductId: string) {
+    return this.stripe.prices.search({
+      query: `product: '${stripeProductId}'`,
+    });
+  }
+
+  async updateSubscriptionItem(stripeItemId: string, quantity: number) {
+    await this.stripe.subscriptionItems.update(stripeItemId, { quantity });
+  }
+
+  async cancelSubscription(stripeSubscriptionId: string) {
+    await this.stripe.subscriptions.cancel(stripeSubscriptionId);
+  }
+
+  async createBillingPortalSession(
+    stripeCustomerId: string,
+    returnUrl?: string,
+  ): Promise<Stripe.BillingPortal.Session> {
+    return await this.stripe.billingPortal.sessions.create({
+      customer: stripeCustomerId,
+      return_url: returnUrl ?? this.environmentService.get('FRONT_BASE_URL'),
+    });
+  }
+
+  async createCheckoutSession(
+    user: User,
+    priceId: string,
+    quantity: number,
+    successUrl?: string,
+    cancelUrl?: string,
+    stripeCustomerId?: string,
+  ): Promise<Stripe.Checkout.Session> {
+    return await this.stripe.checkout.sessions.create({
+      line_items: [
+        {
+          price: priceId,
+          quantity,
+        },
+      ],
+      mode: 'subscription',
+      subscription_data: {
+        metadata: {
+          workspaceId: user.defaultWorkspace.id,
+        },
+        trial_period_days: this.environmentService.get(
+          'BILLING_FREE_TRIAL_DURATION_IN_DAYS',
+        ),
+      },
+      automatic_tax: { enabled: true },
+      tax_id_collection: { enabled: true },
+      customer: stripeCustomerId,
+      customer_update: stripeCustomerId ? { name: 'auto' } : undefined,
+      customer_email: stripeCustomerId ? undefined : user.email,
+      success_url: successUrl,
+      cancel_url: cancelUrl,
+    });
+  }
+
+  async collectLastInvoice(stripeSubscriptionId: string) {
+    const subscription = await this.stripe.subscriptions.retrieve(
+      stripeSubscriptionId,
+      { expand: ['latest_invoice'] },
+    );
+    const latestInvoice = subscription.latest_invoice;
+
+    if (
+      !(
+        latestInvoice &&
+        typeof latestInvoice !== 'string' &&
+        latestInvoice.status === 'draft'
+      )
+    ) {
+      return;
+    }
+    await this.stripe.invoices.pay(latestInvoice.id);
+  }
+}