feat: Improve subscription workflow

apps/backend/.env.example

@@ -10,8 +10,10 @@ IOS_TOKEN=
 # Database
 DATABASE_URL="postgresql://postgres:postgres@localhost:5432"
 
-# Stripe 
+# Stripe
 STRIPE_SECRET_KEY=""
+# Webhook signing secret (whsec_...) – use for constructEvent in production
+STRIPE_WEBHOOK_SECRET=""
 
 # TMDB 
 TMDB_ACCESS_TOKEN=

apps/backend/package.json

@@ -64,7 +64,7 @@
     "drizzle-zod": "^0.8.3",
     "env-paths": "^3.0.0",
     "fast-xml-parser": "^5.3.3",
-    "fastify": "^5.6.2",
+    "fastify": "^5.7.4",
     "fastify-type-provider-zod": "^6.1.0",
     "google-auth-library": "^9.14.0",
     "https": "^1.0.0",

apps/backend/src/config.ts

@@ -28,6 +28,7 @@ function loadServicesEnvs() {
   const schema = z.object({
     RESEND_API_KEY: z.string().optional().default('re_123'),
     STRIPE_SECRET_KEY: z.string().optional().default(''),
+    STRIPE_WEBHOOK_SECRET: z.string().optional().default(''),
     TMDB_ACCESS_TOKEN: z.string(),
   })
 

apps/backend/src/domain/errors/subscription-already-canceled-error.ts

@@ -0,0 +1,7 @@
+import { DomainError } from './domain-error'
+
+export class SubscriptionAlreadyCanceledError extends DomainError {
+  constructor() {
+    super('Subscription is already canceled', 409)
+  }
+}

apps/backend/src/domain/services/imports/publish-import-to-queue.spec.ts

@@ -1,37 +1,25 @@
-import { DeleteQueueCommand, ReceiveMessageCommand } from '@aws-sdk/client-sqs'
-import { afterEach, beforeEach, describe, expect, it } from 'vitest'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
 import { config } from '@/config'
-import { createSqsClient, initializeSQS } from '@/infra/adapters/sqs'
 import { makeManyRawImportMovies } from '@/test/factories/make-import-movies'
 import { makeManyRawImportSeries } from '@/test/factories/make-import-series'
 import { makeUser } from '@/test/factories/make-user'
 import { makeUserImport } from '@/test/factories/make-user-import'
 import { publishToQueue } from './publish-import-to-queue'
 
-describe('publishToQueue', () => {
-  let sqsClient: ReturnType<typeof createSqsClient>
-
-  const queues = [
-    config.sqsQueues.IMPORT_MOVIES_QUEUE,
-    config.sqsQueues.IMPORT_SERIES_QUEUE,
-  ]
+const mockPublish = vi.fn().mockResolvedValue(undefined)
 
-  beforeEach(async () => {
-    sqsClient = createSqsClient()
-    await initializeSQS(sqsClient)
-  })
+vi.mock('@/infra/factories/queue-service-factory', () => ({
+  queueServiceFactory: () => ({
+    publish: mockPublish,
+  }),
+}))
 
-  afterEach(async () => {
-    for (const queue of queues) {
-      await sqsClient.send(
-        new DeleteQueueCommand({
-          QueueUrl: `http://localhost:4566/000000000000/${queue}`,
-        })
-      )
-    }
+describe('publishToQueue', () => {
+  beforeEach(() => {
+    mockPublish.mockClear()
   })
 
-  it('should be able to send messages to SQS', async () => {
+  it('should publish movies and series to their queues', async () => {
     const { id: userId } = await makeUser({})
 
     const movies = makeManyRawImportMovies(3, {})
@@ -40,104 +28,32 @@ describe('publishToQueue', () => {
 
     await publishToQueue(result)
 
-    const receiveMovies = {
-      QueueUrl: config.sqsQueues.IMPORT_MOVIES_QUEUE,
-      MaxNumberOfMessages: 3,
-      WaitTimeSeconds: 1,
-    }
-
-    const receivedMovies = await sqsClient.send(
-      new ReceiveMessageCommand(receiveMovies)
-    )
-
-    expect(receivedMovies.Messages).toHaveLength(3)
-
-    const receiveSeries = {
-      QueueUrl: config.sqsQueues.IMPORT_SERIES_QUEUE,
-      MaxNumberOfMessages: 8,
-      WaitTimeSeconds: 1,
-    }
-
-    const receivedSeries = await sqsClient.send(
-      new ReceiveMessageCommand(receiveSeries)
+    await vi.waitFor(() => {
+      expect(mockPublish).toHaveBeenCalledTimes(2)
+    })
+
+    const [moviesCall, seriesCall] = mockPublish.mock.calls
+
+    expect(moviesCall[0].queueUrl).toBe(config.sqsQueues.IMPORT_MOVIES_QUEUE)
+    expect(moviesCall[0].messages).toHaveLength(3)
+    expect(moviesCall[0].messages).toEqual(
+      result.movies.map(({ id, name }) => ({
+        id,
+        name,
+        provider: result.provider,
+        userId,
+      }))
     )
 
-    expect(receivedSeries.Messages).toHaveLength(8)
-
-    const firstSerie = result.series[0]
-    const formattedSeries = {
-      id: firstSerie.id,
-      name: firstSerie.name,
-      provider: result.provider,
-      userId,
-    }
-
-    expect(receivedSeries.Messages?.[0].Body).toBe(
-      JSON.stringify(formattedSeries)
+    expect(seriesCall[0].queueUrl).toBe(config.sqsQueues.IMPORT_SERIES_QUEUE)
+    expect(seriesCall[0].messages).toHaveLength(8)
+    expect(seriesCall[0].messages).toEqual(
+      result.series.map(({ id, name }) => ({
+        id,
+        name,
+        provider: result.provider,
+        userId,
+      }))
     )
   })
-
-  // it('should not be able to publish movies when it is empty', async () => {
-  //   const { id: userId } = await makeUser({})
-
-  //   const series = makeManyRawImportSeries(3, {})
-  //   const result = await makeUserImport({ userId, movies: [], series })
-
-  //   await publishToQueue(result)
-
-  //   const receiveMovies = {
-  //     QueueUrl: config.sqsQueues.IMPORT_MOVIES_QUEUE,
-  //     MaxNumberOfMessages: 1,
-  //     WaitTimeSeconds: 1,
-  //   }
-
-  //   const receiveSeries = {
-  //     QueueUrl: config.sqsQueues.IMPORT_SERIES_QUEUE,
-  //     MaxNumberOfMessages: 3,
-  //     WaitTimeSeconds: 1,
-  //   }
-
-  //   const receivedMovies = await sqsClient.send(
-  //     new ReceiveMessageCommand(receiveMovies)
-  //   )
-
-  //   const receivedSeries = await sqsClient.send(
-  //     new ReceiveMessageCommand(receiveSeries)
-  //   )
-
-  //   expect(receivedMovies.Messages).toBeUndefined()
-  //   expect(receivedSeries.Messages).toHaveLength(3)
-  // })
-
-  // it('should not be able to publish series when it is empty', async () => {
-  //   const { id: userId } = await makeUser({})
-
-  //   const movies = makeManyRawImportMovies(3, {})
-  //   const result = await makeUserImport({ userId, movies, series: [] })
-
-  //   await publishToQueue(result)
-
-  //   const receiveMovies = {
-  //     QueueUrl: config.sqsQueues.IMPORT_MOVIES_QUEUE,
-  //     MaxNumberOfMessages: 3,
-  //     WaitTimeSeconds: 1,
-  //   }
-
-  //   const receiveSeries = {
-  //     QueueUrl: config.sqsQueues.IMPORT_SERIES_QUEUE,
-  //     MaxNumberOfMessages: 1,
-  //     WaitTimeSeconds: 0.1,
-  //   }
-
-  //   const receivedMovies = await sqsClient.send(
-  //     new ReceiveMessageCommand(receiveMovies)
-  //   )
-
-  //   const receivedSeries = await sqsClient.send(
-  //     new ReceiveMessageCommand(receiveSeries)
-  //   )
-
-  //   expect(receivedMovies.Messages).toHaveLength(3)
-  //   expect(receivedSeries.Messages).toBeUndefined()
-  // })
-}, 10000)
+})

apps/backend/src/domain/services/subscriptions/cancel-subscription.spec.ts

@@ -1,12 +1,25 @@
+import { randomUUID } from 'node:crypto'
 import { faker } from '@faker-js/faker'
-import { describe, expect, it, type Mock } from 'vitest'
-import { stripe } from '@/infra/adapters/stripe'
+import { describe, expect, it } from 'vitest'
+import { SubscriptionAlreadyCanceledError } from '@/domain/errors/subscription-already-canceled-error'
 import { getSubscriptionById } from '@/infra/db/repositories/subscription-repository'
 import { getUserById } from '@/infra/db/repositories/user-repository'
+import type { SubscriptionProvider } from '@/infra/ports/subscription-provider'
 import { makeSubscription } from '@/test/factories/make-subscription'
 import { makeUser } from '@/test/factories/make-user'
 import { cancelSubscription } from './cancel-subscription'
 
+function uniqueProviderSubId() {
+  return `sub_${randomUUID().replace(/-/g, '')}`
+}
+
+function mockSubscriptionProvider(): SubscriptionProvider {
+  return {
+    getCurrentPeriodEnd: vi.fn(),
+    scheduleCancelAtPeriodEnd: vi.fn(),
+    cancelImmediately: vi.fn().mockResolvedValue(undefined),
+  }
+}
 vi.mock('@/infra/adapters/stripe', () => ({
   stripe: {
     subscriptions: {
@@ -17,10 +30,13 @@ vi.mock('@/infra/adapters/stripe', () => ({
 
 describe('Cancel subscription', () => {
   it('should cancel the subscription', async () => {
+    const providerSubId = uniqueProviderSubId()
     const user = await makeUser()
+    const provider = mockSubscriptionProvider()
 
     const subscription = await makeSubscription({
       userId: user.id,
+      providerSubscriptionId: providerSubId,
     })
 
     expect(subscription).toMatchObject({
@@ -30,17 +46,11 @@ describe('Cancel subscription', () => {
       canceledAt: null,
     })
 
-    const mockStripeResponse = {
-      id: subscription.id,
-      status: 'canceled',
-    }
-    ;(stripe.subscriptions.cancel as Mock).mockResolvedValue(mockStripeResponse)
-
     const reason = faker.lorem.sentence(5)
 
-    await cancelSubscription(subscription, reason)
+    await cancelSubscription(subscription, reason, provider)
 
-    expect(stripe.subscriptions.cancel).toHaveBeenCalledWith(subscription.id)
+    expect(provider.cancelImmediately).toHaveBeenCalledWith(providerSubId)
 
     const updatedSubscription = await getSubscriptionById(subscription.id)
 
@@ -53,23 +63,20 @@ describe('Cancel subscription', () => {
   })
 
   it('should update user subscription status after cancel', async () => {
+    const providerSubId = uniqueProviderSubId()
     const user = await makeUser()
+    const provider = mockSubscriptionProvider()
 
     const subscription = await makeSubscription({
       userId: user.id,
+      providerSubscriptionId: providerSubId,
     })
 
-    const mockStripeResponse = {
-      id: subscription.id,
-      status: 'canceled',
-    }
-    ;(stripe.subscriptions.cancel as Mock).mockResolvedValue(mockStripeResponse)
-
     const reason = faker.lorem.sentence(5)
 
-    await cancelSubscription(subscription, reason)
+    await cancelSubscription(subscription, reason, provider)
 
-    expect(stripe.subscriptions.cancel).toHaveBeenCalledWith(subscription.id)
+    expect(provider.cancelImmediately).toHaveBeenCalledWith(providerSubId)
 
     await getSubscriptionById(subscription.id)
 
@@ -79,4 +86,42 @@ describe('Cancel subscription', () => {
       subscriptionType: 'MEMBER',
     })
   })
+
+  it('should throw when subscription has no provider subscription id', async () => {
+    const user = await makeUser()
+    const provider = mockSubscriptionProvider()
+
+    const subscription = await makeSubscription({
+      userId: user.id,
+      providerSubscriptionId: null,
+    })
+
+    await expect(
+      cancelSubscription(subscription, 'reason', provider)
+    ).rejects.toThrow(
+      'Cannot cancel: subscription has no provider subscription id'
+    )
+
+    expect(provider.cancelImmediately).not.toHaveBeenCalled()
+  })
+
+  it('should still update DB when provider says subscription already canceled (idempotent)', async () => {
+    const providerSubId = uniqueProviderSubId()
+    const user = await makeUser()
+    const provider = mockSubscriptionProvider()
+    vi.mocked(provider.cancelImmediately).mockRejectedValueOnce(
+      new SubscriptionAlreadyCanceledError()
+    )
+
+    const subscription = await makeSubscription({
+      userId: user.id,
+      providerSubscriptionId: providerSubId,
+    })
+
+    const result = await cancelSubscription(subscription, 'reason', provider)
+
+    expect(result).toEqual({ id: subscription.id })
+    const updated = await getSubscriptionById(subscription.id)
+    expect(updated?.status).toBe('CANCELED')
+  })
 })