perf: merge CMPP inbox validation and persistence

2026-08-20 18:55:09 +08:00
parent 633e7a7055
commit 99fb346566
6 changed files with 303 additions and 32 deletions
@@ -2119,6 +2119,24 @@ describe('SendChainService', () => {
    try {
      const { service, prisma, billing, riskReview, phoneFrequency } = createService();
      service.enqueueBatchTask = jest.fn();
+      prisma.$queryRaw.mockImplementationOnce((query) => {
+        const payloadHash = query.values.find((value: unknown) => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value));
+        return Promise.resolve([{
+          validationError: null,
+          payloadHash,
+          response: {
+            accepted: true,
+            tenantId: 'tenant-1',
+            applicationId: 'app-1',
+            taskId: '',
+            messageId: 'MSG-fast',
+            messageRecordId: '',
+            status: 'accepted_pending',
+            phoneCount: 2,
+            messages: [],
+          },
+        }]);
+      });

      const result = await service.submitInboundMessage({
        requestId: 'cmpp-inbound:test-fast-path',
@@ -2134,13 +2152,12 @@ describe('SendChainService', () => {
        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.smsApplication.findFirst).not.toHaveBeenCalled();
+      expect(prisma.$queryRaw).toHaveBeenCalledTimes(1);
+      const sql = prisma.$queryRaw.mock.calls[0][0].strings.join(' ');
+      expect(sql).toContain('INSERT INTO "CmppInboundSubmissionInbox"');
+      expect(sql).toContain('JOIN "Tenant"');
+      expect(sql).toContain('ON CONFLICT ("requestKey") DO NOTHING');
      expect(prisma.smsBatchTask.create).not.toHaveBeenCalled();
      expect(prisma.smsMessageRecord.create).not.toHaveBeenCalled();
      expect(riskReview.evaluateTask).not.toHaveBeenCalled();
@@ -2158,7 +2175,6 @@ describe('SendChainService', () => {
    process.env.CMPP_INBOUND_FAST_PATH_ENABLED = 'true';
    try {
      const { service, prisma } = createService();
-      let originalHash = '';
      const storedResponse = {
        accepted: true,
        tenantId: 'tenant-1',
@@ -2170,19 +2186,10 @@ describe('SendChainService', () => {
        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,
-      }));
+      prisma.$queryRaw.mockImplementation((query) => {
+        const payloadHash = query.values.find((value: unknown) => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value));
+        return Promise.resolve([{ validationError: null, payloadHash, response: storedResponse }]);
+      });
      const request = {
        requestId: 'cmpp-inbound:test-retry',
        account: '100001',
@@ -2194,7 +2201,8 @@ describe('SendChainService', () => {

      await service.submitInboundMessage(request);
      await expect(service.submitInboundMessage(request)).resolves.toEqual(storedResponse);
-      expect(prisma.cmppInboundSubmissionInbox.create).toHaveBeenCalledTimes(2);
+      expect(prisma.$queryRaw).toHaveBeenCalledTimes(2);
+      expect(prisma.cmppInboundSubmissionInbox.findUnique).not.toHaveBeenCalled();
      expect(prisma.smsMessageRecord.create).not.toHaveBeenCalled();
    } finally {
      if (previous == null) delete process.env.CMPP_INBOUND_FAST_PATH_ENABLED;
@@ -2202,6 +2210,58 @@ describe('SendChainService', () => {
    }
  });

+  it('rejects a disabled application before the merged Inbox statement can insert', async () => {
+    const previous = process.env.CMPP_INBOUND_FAST_PATH_ENABLED;
+    process.env.CMPP_INBOUND_FAST_PATH_ENABLED = 'true';
+    try {
+      const { service, prisma } = createService();
+      prisma.$queryRaw.mockResolvedValueOnce([{
+        validationError: 'CMPP account is disabled for new submissions',
+        payloadHash: null,
+        response: null,
+      }]);
+
+      await expect(service.submitInboundMessage({
+        requestId: 'cmpp-inbound:disabled',
+        account: '100001',
+        phoneNumber: '13800000001',
+        content: 'hello',
+      })).rejects.toThrow('CMPP account is disabled for new submissions');
+      expect(prisma.cmppInboundSubmissionInbox.findUnique).not.toHaveBeenCalled();
+    } finally {
+      if (previous == null) delete process.env.CMPP_INBOUND_FAST_PATH_ENABLED;
+      else process.env.CMPP_INBOUND_FAST_PATH_ENABLED = previous;
+    }
+  });
+
+  it('uses a read-only recovery only for a concurrent Inbox insert outside the CTE snapshot', async () => {
+    const previous = process.env.CMPP_INBOUND_FAST_PATH_ENABLED;
+    process.env.CMPP_INBOUND_FAST_PATH_ENABLED = 'true';
+    try {
+      const { service, prisma } = createService();
+      let payloadHash = '';
+      prisma.$queryRaw.mockImplementationOnce((query) => {
+        payloadHash = query.values.find((value: unknown) => typeof value === 'string' && /^[a-f0-9]{64}$/.test(value));
+        return Promise.resolve([{ validationError: null, payloadHash: null, response: null }]);
+      });
+      prisma.cmppInboundSubmissionInbox.findUnique.mockImplementationOnce(() => Promise.resolve({
+        payloadHash,
+        response: { accepted: true, messageId: 'MSG-concurrent', status: 'accepted_pending' },
+      }));
+
+      await expect(service.submitInboundMessage({
+        requestId: 'cmpp-inbound:concurrent',
+        account: '100001',
+        phoneNumber: '13800000001',
+        content: 'hello',
+      })).resolves.toEqual(expect.objectContaining({ messageId: 'MSG-concurrent' }));
+      expect(prisma.cmppInboundSubmissionInbox.findUnique).toHaveBeenCalledTimes(1);
+    } finally {
+      if (previous == null) delete process.env.CMPP_INBOUND_FAST_PATH_ENABLED;
+      else process.env.CMPP_INBOUND_FAST_PATH_ENABLED = previous;
+    }
+  });
+
  it('persists an idempotent daily quota reservation with a Prisma Date value', async () => {
    const { service, prisma } = createService();
    prisma.$queryRaw.mockResolvedValueOnce([{ tenantId: 'tenant-1', dailyLimit: 100000, usedCount: 1 }]);