merge test

Author: ymc9

packages/clients/tanstack-query/test/react-query.test.tsx

@@ -4,11 +4,12 @@
 
 import { QueryClient, QueryClientProvider, useQuery } from '@tanstack/react-query';
 import { act, cleanup, renderHook, waitFor } from '@testing-library/react';
+import { deserialize, serialize } from '@zenstackhq/client-helpers/fetch';
 import nock from 'nock';
 import React from 'react';
 import { afterEach, describe, expect, it } from 'vitest';
 import { getQueryKey } from '../src/common/query-key';
-import { QuerySettingsProvider, useClientQueries } from '../src/react';
+import { AnyNull, DbNull, JsonNull, QuerySettingsProvider, useClientQueries } from '../src/react';
 import { schema } from './schemas/basic/schema-lite';
 
 const BASE_URL = 'http://localhost';
@@ -1817,10 +1818,9 @@ describe('React Query Test', () => {
                 return { data: [users[0], posts[0]] };
             });
 
-        const { result: txResult } = renderHook(
-            () => useClientQueries(schema).$transaction.useSequential(),
-            { wrapper },
-        );
+        const { result: txResult } = renderHook(() => useClientQueries(schema).$transaction.useSequential(), {
+            wrapper,
+        });
 
         act(() =>
             txResult.current.mutate([
@@ -1865,9 +1865,7 @@ describe('React Query Test', () => {
             { wrapper },
         );
 
-        act(() =>
-            txResult.current.mutate([{ model: 'User', op: 'create', args: { data: { email: 'foo@bar.com' } } }]),
-        );
+        act(() => txResult.current.mutate([{ model: 'User', op: 'create', args: { data: { email: 'foo@bar.com' } } }]));
 
         await waitFor(() => {
             expect(txResult.current.isSuccess).toBe(true);
@@ -1876,4 +1874,140 @@ describe('React Query Test', () => {
             expect(cachedUsers).toHaveLength(0);
         });
     });
+
+    describe('JSON null value serialization', () => {
+        function createWrapper() {
+            const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+            const wrapper = ({ children }: { children: React.ReactNode }) => (
+                <QueryClientProvider client={queryClient}>
+                    <QuerySettingsProvider value={{ endpoint: `${BASE_URL}/api/model` }}>
+                        {children}
+                    </QuerySettingsProvider>
+                </QueryClientProvider>
+            );
+            return { queryClient, wrapper };
+        }
+
+        it('encodes DbNull in query filter and includes serialization metadata in URL', async () => {
+            const { wrapper } = createWrapper();
+            let capturedUri = '';
+
+            nock(BASE_URL)
+                .get(/.*/)
+                .reply(200, function (uri) {
+                    capturedUri = uri;
+                    return { data: [] };
+                });
+
+            const { result } = renderHook(
+                () => useClientQueries(schema).user.useFindMany({ where: { name: DbNull } } as any),
+                { wrapper },
+            );
+
+            await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+            const url = new URL(capturedUri, BASE_URL);
+            expect(url.searchParams.has('meta')).toBe(true);
+
+            const q = JSON.parse(decodeURIComponent(url.searchParams.get('q')!));
+            const meta = JSON.parse(decodeURIComponent(url.searchParams.get('meta')!));
+            const reconstructed = deserialize(q, meta.serialization) as any;
+            expect(reconstructed.where.name.__brand).toBe('DbNull');
+        });
+
+        it('encodes JsonNull in query filter and includes serialization metadata in URL', async () => {
+            const { wrapper } = createWrapper();
+            let capturedUri = '';
+
+            nock(BASE_URL)
+                .get(/.*/)
+                .reply(200, function (uri) {
+                    capturedUri = uri;
+                    return { data: [] };
+                });
+
+            const { result } = renderHook(
+                () => useClientQueries(schema).user.useFindMany({ where: { name: JsonNull } } as any),
+                { wrapper },
+            );
+
+            await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+            const url = new URL(capturedUri, BASE_URL);
+            expect(url.searchParams.has('meta')).toBe(true);
+
+            const q = JSON.parse(decodeURIComponent(url.searchParams.get('q')!));
+            const meta = JSON.parse(decodeURIComponent(url.searchParams.get('meta')!));
+            const reconstructed = deserialize(q, meta.serialization) as any;
+            expect(reconstructed.where.name.__brand).toBe('JsonNull');
+        });
+
+        it('encodes AnyNull in query filter and includes serialization metadata in URL', async () => {
+            const { wrapper } = createWrapper();
+            let capturedUri = '';
+
+            nock(BASE_URL)
+                .get(/.*/)
+                .reply(200, function (uri) {
+                    capturedUri = uri;
+                    return { data: [] };
+                });
+
+            const { result } = renderHook(
+                () => useClientQueries(schema).user.useFindMany({ where: { name: AnyNull } } as any),
+                { wrapper },
+            );
+
+            await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+            const url = new URL(capturedUri, BASE_URL);
+            expect(url.searchParams.has('meta')).toBe(true);
+
+            const q = JSON.parse(decodeURIComponent(url.searchParams.get('q')!));
+            const meta = JSON.parse(decodeURIComponent(url.searchParams.get('meta')!));
+            const reconstructed = deserialize(q, meta.serialization) as any;
+            expect(reconstructed.where.name.__brand).toBe('AnyNull');
+        });
+
+        it('encodes DbNull in mutation body with serialization metadata', async () => {
+            const { wrapper } = createWrapper();
+            let capturedBody: any;
+
+            nock(BASE_URL)
+                .post(/.*/)
+                .reply(200, function (_uri, body) {
+                    capturedBody = body;
+                    return { data: { id: '1', name: null } };
+                });
+
+            const { result } = renderHook(() => useClientQueries(schema).user.useCreate(), { wrapper });
+
+            act(() => result.current.mutate({ data: { email: 'test@example.com', name: DbNull } } as any));
+
+            await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+            expect(capturedBody.meta?.serialization).toBeDefined();
+            const reconstructed = deserialize({ data: capturedBody.data }, capturedBody.meta.serialization) as any;
+            expect(reconstructed.data.name.__brand).toBe('DbNull');
+        });
+
+        it('deserializes null sentinels in server response back to branded instances', async () => {
+            const { wrapper } = createWrapper();
+
+            const responseData = { id: '1', email: 'test@example.com', name: DbNull };
+            const { data: serializedData, meta: serializedMeta } = serialize(responseData);
+
+            nock(BASE_URL)
+                .get(/.*/)
+                .reply(200, { data: serializedData, meta: { serialization: serializedMeta } });
+
+            const { result } = renderHook(() => useClientQueries(schema).user.useFindUnique({ where: { id: '1' } }), {
+                wrapper,
+            });
+
+            await waitFor(() => expect(result.current.isSuccess).toBe(true));
+
+            expect((result.current.data as any).name.__brand).toBe('DbNull');
+        });
+    });
 });