perf(cmpp): add durable inbound fast path

2026-08-20 17:34:45 +08:00
parent 26ef67fb6a
commit 0b63bcd74e
29 changed files with 1136 additions and 87 deletions
@@ -329,6 +329,13 @@ function createPrismaMock() {
        lastError: 'downstream client is not connected',
      }),
    },
+    cmppInboundSubmissionInbox: {
+      create: jest.fn().mockResolvedValue({ id: 'inbox-1' }),
+      findUnique: jest.fn().mockResolvedValue(null),
+      updateMany: jest.fn().mockResolvedValue({ count: 1 }),
+      count: jest.fn().mockResolvedValue(0),
+      findFirst: jest.fn().mockResolvedValue(null),
+    },
    smsBillingRecord: {
      findFirst: jest.fn().mockResolvedValue(null),
      create: jest.fn().mockResolvedValue({ id: 'bill-1' }),
@@ -2098,6 +2105,95 @@ describe('SendChainService', () => {
    });
  });

+  it('returns from the durable CMPP Inbox fast path before risk, billing, or queue publication', async () => {
+    const previous = process.env.CMPP_INBOUND_FAST_PATH_ENABLED;
+    process.env.CMPP_INBOUND_FAST_PATH_ENABLED = 'true';
+    try {
+      const { service, prisma, billing, riskReview, phoneFrequency } = createService();
+      service.enqueueBatchTask = jest.fn();
+
+      const result = await service.submitInboundMessage({
+        requestId: 'cmpp-inbound:test-fast-path',
+        account: '100001',
+        phoneNumbers: ['13800000001', '13900000002'],
+        content: 'hello',
+        sequenceId: 777,
+        remoteIp: '127.0.0.1',
+      });
+
+      expect(result).toEqual(expect.objectContaining({
+        accepted: true,
+        status: 'accepted_pending',
+        phoneCount: 2,
+      }));
+      expect(prisma.cmppInboundSubmissionInbox.create).toHaveBeenCalledWith({
+        data: expect.objectContaining({
+          requestKey: 'cmpp-inbound:test-fast-path',
+          tenantId: 'tenant-1',
+          applicationId: 'app-1',
+        }),
+      });
+      expect(prisma.smsBatchTask.create).not.toHaveBeenCalled();
+      expect(prisma.smsMessageRecord.create).not.toHaveBeenCalled();
+      expect(riskReview.evaluateTask).not.toHaveBeenCalled();
+      expect(phoneFrequency.reserve).not.toHaveBeenCalled();
+      expect(billing.freeze).not.toHaveBeenCalled();
+      expect(service.enqueueBatchTask).not.toHaveBeenCalled();
+    } finally {
+      if (previous == null) delete process.env.CMPP_INBOUND_FAST_PATH_ENABLED;
+      else process.env.CMPP_INBOUND_FAST_PATH_ENABLED = previous;
+    }
+  });
+
+  it('returns the stored SubmitResp for an idempotent CMPP Inbox retry', async () => {
+    const previous = process.env.CMPP_INBOUND_FAST_PATH_ENABLED;
+    process.env.CMPP_INBOUND_FAST_PATH_ENABLED = 'true';
+    try {
+      const { service, prisma } = createService();
+      let originalHash = '';
+      const storedResponse = {
+        accepted: true,
+        tenantId: 'tenant-1',
+        applicationId: 'app-1',
+        taskId: '',
+        messageId: 'MSG-stable',
+        messageRecordId: '',
+        status: 'accepted_pending',
+        phoneCount: 1,
+        messages: [{ phoneNumber: '13800000001', messageId: 'MSG-stable', messageRecordId: '', taskId: '', status: 'accepted_pending' }],
+      };
+      prisma.cmppInboundSubmissionInbox.create
+        .mockImplementationOnce(({ data }) => {
+          originalHash = data.payloadHash;
+          return Promise.resolve({ id: 'inbox-1' });
+        })
+        .mockRejectedValueOnce(new Prisma.PrismaClientKnownRequestError('duplicate request key', {
+          code: 'P2002',
+          clientVersion: '7.9.0',
+        }));
+      prisma.cmppInboundSubmissionInbox.findUnique.mockImplementation(() => Promise.resolve({
+        payloadHash: originalHash,
+        response: storedResponse,
+      }));
+      const request = {
+        requestId: 'cmpp-inbound:test-retry',
+        account: '100001',
+        phoneNumber: '13800000001',
+        content: 'hello',
+        sequenceId: 778,
+        remoteIp: '127.0.0.1',
+      };
+
+      await service.submitInboundMessage(request);
+      await expect(service.submitInboundMessage(request)).resolves.toEqual(storedResponse);
+      expect(prisma.cmppInboundSubmissionInbox.create).toHaveBeenCalledTimes(2);
+      expect(prisma.smsMessageRecord.create).not.toHaveBeenCalled();
+    } finally {
+      if (previous == null) delete process.env.CMPP_INBOUND_FAST_PATH_ENABLED;
+      else process.env.CMPP_INBOUND_FAST_PATH_ENABLED = previous;
+    }
+  });
+
  it('enqueues a freshly persisted inbound message without querying the task and message again', async () => {
    const { service, prisma } = createService();
    const add = jest.fn().mockResolvedValue(undefined);