@openapi-qraft/react 1.0.0-beta.4 → 1.0.0-beta.6

package/src/lib/shelfMerge.ts

@@ -0,0 +1,35 @@
+/**
+ * Merges objects with provided depth
+ * @param depth
+ * @param args
+ */
+export function shelfMerge<T>(depth = 2, ...args: T[]): T {
+  return args.reduce((acc, arg) => {
+    if (!arg || typeof arg !== 'object') return acc;
+
+    Object.entries(arg).forEach(([key, value]) => {
+      if (typeof value !== 'object') {
+        acc[key as never] = value as never;
+        return;
+      }
+
+      if (Array.isArray(value)) {
+        acc[key as never] = value as never;
+        return;
+      }
+
+      if (depth > 1) {
+        acc[key as never] = shelfMerge(
+          depth - 1,
+          acc[key as never],
+          value
+        ) as never;
+        return;
+      }
+
+      acc[key as never] = value as never;
+    });
+
+    return acc;
+  }, {} as T);
+}

package/src/qraftAPIClient.test.tsx

@@ -9,8 +9,8 @@ import {
 import { act, renderHook, waitFor } from '@testing-library/react';
 
 import { createAPIClient } from './fixtures/api/index.js';
-import { bodySerializer, urlSerializer, request } from './lib/request.js';
-import { QraftContext, QraftContextValue } from './QraftContext.js';
+import { bodySerializer, request, urlSerializer } from './lib/request.js';
+import { QraftContextValue } from './QraftContext.js';
 import type { RequestClient } from './RequestClient.js';
 
 const qraft = createAPIClient();
@@ -130,6 +130,58 @@ describe('Qraft uses Queries', () => {
   });
 });
 
+describe('Qraft uses Suspense Queries', () => {
+  it('supports useSuspenseQuery', async () => {
+    const hook = () => {
+      try {
+        return qraft.approvalPolicies.getApprovalPoliciesId.useSuspenseQuery({
+          header: {
+            'x-monite-version': '1.0.0',
+          },
+          path: {
+            approval_policy_id: '1',
+          },
+          query: {
+            items_order: ['asc', 'desc'],
+          },
+        });
+      } catch (error) {
+        return error as Promise<unknown>;
+      }
+    };
+
+    const queryClient = new QueryClient();
+
+    const { result: resultWithErrorPromise } = renderHook(hook, {
+      wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+    });
+
+    expect(resultWithErrorPromise.current).toBeInstanceOf(Promise); // Suspense throws a promise
+
+    await resultWithErrorPromise.current;
+
+    const { result: resultWithData } = renderHook(hook, {
+      wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+    });
+
+    if (resultWithData.current instanceof Promise) {
+      throw new Error('Promise should be resolved');
+    }
+
+    expect(resultWithData.current.data).toEqual({
+      header: {
+        'x-monite-version': '1.0.0',
+      },
+      path: {
+        approval_policy_id: '1',
+      },
+      query: {
+        items_order: ['asc', 'desc'],
+      },
+    });
+  });
+});
+
 describe('Qraft uses Infinite Queries', () => {
   it('supports useInfiniteQuery', async () => {
     const { result } = renderHook(
@@ -292,6 +344,86 @@ describe('Qraft uses Infinite Queries', () => {
   });
 });
 
+describe('Qraft uses Suspense Infinite Queries', () => {
+  it('supports useSuspenseInfiniteQuery', async () => {
+    const hook = () => {
+      try {
+        return qraft.files.getFiles.useSuspenseInfiniteQuery(
+          {
+            header: {
+              'x-monite-version': '1.0.0',
+            },
+            query: {
+              id__in: ['1', '2'],
+            },
+          },
+          {
+            getNextPageParam: (lastPage, allPages, params) => {
+              return {
+                query: {
+                  page: params.query?.page
+                    ? String(Number(params.query.page) + 1)
+                    : undefined,
+                },
+              };
+            },
+            initialPageParam: {
+              query: {
+                page: '1',
+              },
+            },
+          }
+        );
+      } catch (error) {
+        return error as Promise<unknown>;
+      }
+    };
+
+    const queryClient = new QueryClient();
+
+    const { result } = renderHook(hook, {
+      wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+    });
+
+    const { result: resultWithErrorPromise } = renderHook(hook, {
+      wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+    });
+
+    expect(resultWithErrorPromise.current).toBeInstanceOf(Promise); // Suspense throws a promise
+
+    await resultWithErrorPromise.current;
+
+    const { result: resultWithData } = renderHook(hook, {
+      wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+    });
+
+    if (resultWithData.current instanceof Promise) {
+      throw new Error('Promise should be resolved');
+    }
+
+    expect(resultWithData.current.data).toEqual({
+      pageParams: [
+        {
+          query: {
+            page: '1',
+          },
+        },
+      ],
+      pages: [
+        {
+          header: {
+            'x-monite-version': '1.0.0',
+          },
+          query: {
+            id__in: ['1', '2'],
+            page: '1',
+          },
+        },
+      ],
+    });
+  });
+});
+
 describe('Qraft uses Mutations', () => {
   it('supports useMutation without predefined parameters', async () => {
     const { result } = renderHook(
@@ -408,6 +540,230 @@ describe('Qraft uses Mutations', () => {
   });
 });
 
+describe('Qraft uses Mutation State', () => {
+  const parameters = {
+    header: {
+      'x-monite-version': '1.0.0',
+    },
+    path: {
+      entity_id: '1',
+    },
+    query: {
+      referer: 'https://example.com',
+    },
+  } as const;
+
+  it('supports useMutationState with filter', async () => {
+    const queryClient = new QueryClient();
+
+    const { result: mutationResult } = renderHook(
+      () => qraft.entities.postEntitiesIdDocuments.useMutation(parameters),
+      {
+        wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+      }
+    );
+
+    act(() => {
+      mutationResult.current.mutate({
+        verification_document_back: 'back',
+        verification_document_front: 'front',
+      });
+    });
+
+    await waitFor(() => {
+      expect(mutationResult.current.data).toBeDefined();
+    });
+
+    const { result: mutationStateResult } = renderHook(
+      () =>
+        qraft.entities.postEntitiesIdDocuments.useMutationState({
+          filters: {
+            parameters,
+          },
+        }),
+      {
+        wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+      }
+    );
+
+    expect(mutationStateResult.current.at(0)?.data).toEqual({
+      body: {
+        verification_document_back: 'back',
+        verification_document_front: 'front',
+      },
+      ...parameters,
+    });
+  });
+
+  it('supports useMutationState with filter and select', async () => {
+    const queryClient = new QueryClient();
+
+    const { result: mutationResult } = renderHook(
+      () => qraft.entities.postEntitiesIdDocuments.useMutation(parameters),
+      {
+        wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+      }
+    );
+
+    act(() => {
+      mutationResult.current.mutate({
+        verification_document_back: 'back',
+        verification_document_front: 'front',
+      });
+    });
+
+    await waitFor(() => {
+      expect(mutationResult.current.data).toBeDefined();
+    });
+
+    const { result: mutationStateResult } = renderHook(
+      () =>
+        qraft.entities.postEntitiesIdDocuments.useMutationState({
+          filters: {
+            parameters,
+          },
+          select(mutation) {
+            return (
+              mutation.state.data?.header?.['x-monite-version'] ===
+              parameters.header['x-monite-version']
+            );
+          },
+        }),
+      {
+        wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+      }
+    );
+
+    expect(mutationStateResult.current.at(0)).toEqual(true);
+  });
+
+  it('supports useMutationState with without filter', async () => {
+    const queryClient = new QueryClient();
+
+    const { result: mutationResult } = renderHook(
+      () => qraft.entities.postEntitiesIdDocuments.useMutation(parameters),
+      {
+        wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+      }
+    );
+
+    act(() => {
+      mutationResult.current.mutate({
+        verification_document_back: 'back',
+        verification_document_front: 'front',
+      });
+    });
+
+    await waitFor(() => {
+      expect(mutationResult.current.data).toBeDefined();
+    });
+
+    const { result: mutationStateResult } = renderHook(
+      () => qraft.entities.postEntitiesIdDocuments.useMutationState(),
+      {
+        wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+      }
+    );
+
+    expect(mutationStateResult.current.at(0)?.data).toEqual({
+      body: {
+        verification_document_back: 'back',
+        verification_document_front: 'front',
+      },
+      ...parameters,
+    });
+  });
+
+  it('supports useMutationState with mutationKey and select', async () => {
+    const queryClient = new QueryClient();
+
+    const { result: mutationHookResultToMatch } = renderHook(
+      () => qraft.entities.postEntitiesIdDocuments.useMutation(parameters),
+      {
+        wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+      }
+    );
+
+    act(() => {
+      mutationHookResultToMatch.current.mutate({
+        verification_document_back: 'back',
+        verification_document_front: 'front',
+      });
+    });
+
+    await waitFor(() => {
+      expect(mutationHookResultToMatch.current.data).toBeDefined();
+    });
+
+    const { result: mutationStateHookResult } = renderHook(
+      () =>
+        qraft.entities.postEntitiesIdDocuments.useMutationState({
+          filters: {
+            mutationKey:
+              qraft.entities.postEntitiesIdDocuments.getMutationKey(parameters),
+          },
+          select(mutation) {
+            return (
+              mutation.state.data?.header?.['x-monite-version'] ===
+              parameters.header['x-monite-version']
+            );
+          },
+        }),
+      {
+        wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+      }
+    );
+
+    expect(mutationStateHookResult.current.length).toEqual(1);
+    expect(mutationStateHookResult.current.at(0)).toEqual(true);
+  });
+
+  it('supports useMutationState with not partial parameters', async () => {
+    const queryClient = new QueryClient();
+
+    const { result: mutationHookResultToMatch } = renderHook(
+      () => qraft.entities.postEntitiesIdDocuments.useMutation(parameters),
+      {
+        wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+      }
+    );
+
+    act(() => {
+      mutationHookResultToMatch.current.mutate({
+        verification_document_back: 'back',
+        verification_document_front: 'front',
+      });
+    });
+
+    await waitFor(() => {
+      expect(mutationHookResultToMatch.current.data).toBeDefined();
+    });
+
+    const { result: mutationStateResult } = renderHook(
+      () =>
+        qraft.entities.postEntitiesIdDocuments.useMutationState({
+          filters: {
+            parameters: {
+              header: parameters.header,
+            },
+          },
+          select(mutation) {
+            return (
+              mutation.state.data?.header?.['x-monite-version'] ===
+              parameters.header['x-monite-version']
+            );
+          },
+        }),
+      {
+        wrapper: (props) => <Providers {...props} queryClient={queryClient} />,
+      }
+    );
+
+    expect(mutationStateResult.current.length).toEqual(1);
+    expect(mutationStateResult.current.at(0)).toEqual(true);
+  });
+});
+
 describe('Qraft uses Query Function', () => {
   it('uses queryFn', async () => {
     const result = await qraft.approvalPolicies.getApprovalPoliciesId.queryFn(