resolve comments

Author: jiashengguo

packages/server/src/api/rpc/index.ts

@@ -7,12 +7,30 @@ import z from 'zod';
 import { fromError } from 'zod-validation-error/v4';
 import type { ApiHandler, LogConfig, RequestContext, Response } from '../../types';
 import { getProcedureDef, mapProcedureArgs, PROCEDURE_ROUTE_PREFIXES } from '../common/procedures';
-
-const TRANSACTION_ROUTE_PREFIX = '$transaction' as const;
 import { loggerSchema } from '../common/schemas';
 import { processSuperJsonRequestPayload, unmarshalQ } from '../common/utils';
 import { log, registerCustomSerializers } from '../utils';
 
+const TRANSACTION_ROUTE_PREFIX = '$transaction' as const;
+const VALID_OPS = new Set([
+    'create',
+    'createMany',
+    'createManyAndReturn',
+    'upsert',
+    'findFirst',
+    'findUnique',
+    'findMany',
+    'aggregate',
+    'groupBy',
+    'count',
+    'exists',
+    'update',
+    'updateMany',
+    'updateManyAndReturn',
+    'delete',
+    'deleteMany',
+]);
+
 registerCustomSerializers();
 
 /**
@@ -77,6 +95,7 @@ export class RPCApiHandler<Schema extends SchemaDef = SchemaDef> implements ApiH
             return this.handleTransaction({
                 client,
                 method: method.toUpperCase(),
+                type: op,
                 requestBody,
             });
         }
@@ -198,38 +217,27 @@ export class RPCApiHandler<Schema extends SchemaDef = SchemaDef> implements ApiH
     private async handleTransaction({
         client,
         method,
+        type,
         requestBody,
     }: {
         client: ClientContract<Schema>;
         method: string;
+        type: string;
         requestBody?: unknown;
     }): Promise<Response> {
         if (method !== 'POST') {
             return this.makeBadInputErrorResponse('invalid request method, only POST is supported');
         }
 
+        if (type !== 'sequential') {
+            return this.makeBadInputErrorResponse(`unsupported transaction type: ${type}`);
+        }
+
         if (!requestBody || !Array.isArray(requestBody) || requestBody.length === 0) {
             return this.makeBadInputErrorResponse('request body must be a non-empty array of operations');
         }
 
-        const VALID_OPS = new Set([
-            'create',
-            'createMany',
-            'createManyAndReturn',
-            'upsert',
-            'findFirst',
-            'findUnique',
-            'findMany',
-            'aggregate',
-            'groupBy',
-            'count',
-            'exists',
-            'update',
-            'updateMany',
-            'updateManyAndReturn',
-            'delete',
-            'deleteMany',
-        ]);
+        const processedOps: Array<{ model: string; op: string; args: unknown }> = [];
 
         for (let i = 0; i < requestBody.length; i++) {
             const item = requestBody[i];
@@ -252,16 +260,19 @@ export class RPCApiHandler<Schema extends SchemaDef = SchemaDef> implements ApiH
             if (itemArgs !== undefined && itemArgs !== null && typeof itemArgs !== 'object') {
                 return this.makeBadInputErrorResponse(`operation at index ${i} has invalid "args" field`);
             }
-        }
 
-        const promises = (requestBody as any[]).map((item) => {
-            const model = lowerCaseFirst(item.model as string);
-            const op = item.op as string;
-            const args = item.args ?? {};
-            return (client as any)[model][op](args);
-        });
+            const { result: processedArgs, error: argsError } = await this.processRequestPayload(itemArgs ?? {});
+            if (argsError) {
+                return this.makeBadInputErrorResponse(`operation at index ${i}: ${argsError}`);
+            }
+            processedOps.push({ model: lowerCaseFirst(itemModel), op: itemOp, args: processedArgs });
+        }
 
         try {
+            const promises = processedOps.map(({ model, op, args }) => {
+                return (client as any)[model][op](args);
+            });
+
             log(this.options.log, 'debug', () => `handling "$transaction" request with ${promises.length} operations`);
 
             const clientResult = await client.$transaction(promises as any);

packages/server/test/api/rpc.test.ts

@@ -950,6 +950,55 @@ procedure echoOverview(o: Overview): Overview
             expect(r.error.message).toMatch(/validation error/i);
         });
 
+        it('deserializes SuperJSON-encoded args per operation', async () => {
+            const handleRequest = makeHandler();
+
+            // Clean up
+            await rawClient.post.deleteMany();
+            await rawClient.user.deleteMany();
+
+            // Serialize args containing a Date so they need SuperJSON deserialization
+            const publishedAt = new Date('2025-01-15T00:00:00.000Z');
+            const serialized = SuperJSON.serialize({
+                data: { id: 'txuser3', email: 'txuser3@abc.com' },
+            });
+            const serializedPost = SuperJSON.serialize({
+                data: { id: 'txpost3', title: 'Dated Post', authorId: 'txuser3', publishedAt },
+            });
+
+            const r = await handleRequest({
+                method: 'post',
+                path: '/$transaction/sequential',
+                requestBody: [
+                    {
+                        model: 'User',
+                        op: 'create',
+                        args: { ...(serialized.json as any), meta: { serialization: serialized.meta } },
+                    },
+                    {
+                        model: 'Post',
+                        op: 'create',
+                        args: { ...(serializedPost.json as any), meta: { serialization: serializedPost.meta } },
+                    },
+                ],
+                client: rawClient,
+            });
+
+            expect(r.status).toBe(200);
+            expect(r.data).toHaveLength(2);
+            expect(r.data[0]).toMatchObject({ id: 'txuser3' });
+            expect(r.data[1]).toMatchObject({ id: 'txpost3' });
+
+            // Verify the Date was stored correctly
+            const post = await (rawClient as any).post.findUnique({ where: { id: 'txpost3' } });
+            expect(post?.publishedAt instanceof Date).toBe(true);
+            expect((post?.publishedAt as Date)?.toISOString()).toBe(publishedAt.toISOString());
+
+            // Clean up
+            await rawClient.post.deleteMany();
+            await rawClient.user.deleteMany();
+        });
+
         it('rolls back all operations when one fails', async () => {
             const handleRequest = makeHandler();