@websolutespa/bom-mixer-hooks 3.1.0 → 3.1.1

package/CHANGELOG.md

@@ -1,5 +1,7 @@
 # @websolutespa/bom-mixer-hooks
 
+## 3.1.1
+
 ## 3.1.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@websolutespa/bom-mixer-hooks",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "Mixer Hooks module of the BOM Repository",
   "keywords": [
     "bom",
@@ -46,10 +46,10 @@
     "@types/react-dom": "19.2.7",
     "@types/styled-components": "5.1.34",
     "@vitest/coverage-istanbul": "5.0.5",
-    "@websolutespa/bom-cli": "^3.1.0",
-    "@websolutespa/eslint-config": "^3.1.0",
-    "@websolutespa/test": "^3.1.0",
-    "@websolutespa/tsconfig": "^3.1.0",
+    "@websolutespa/bom-cli": "^3.1.1",
+    "@websolutespa/eslint-config": "^3.1.1",
+    "@websolutespa/test": "^3.1.1",
+    "@websolutespa/tsconfig": "^3.1.1",
     "eslint": "10.13.0",
     "npm-run-all": "4.1.5",
     "react": "19.2.9",
@@ -89,12 +89,12 @@
   },
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
-  "source": "./src/index.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     }
-  }
+  },
+  "source": "./src/index.ts"
 }

package/src/useApi/useApi.test.tsx

@@ -1,193 +1,193 @@
-import { render, renderHook, screen, waitFor, waitForElementToBeRemoved } from '@testing-library/react';
-import { ILayout } from '@websolutespa/bom-core';
-import { getLocalApiUrl } from '@websolutespa/bom-mixer-store';
-import { afterAll, beforeEach, describe, expect, test, vi } from 'vitest';
-import { LayoutProvider } from '../useLayout/useLayout';
-import { LayoutDefaults } from '../useLayout/useLayout.default';
-import { useApi, useApiDelete, useApiFetch, useApiGet, useApiPatch, useApiPost, useApiPut } from './useApi';
-
-const wrapper = (props: { children: React.ReactNode }) => (
-  <LayoutProvider layout={LayoutDefaults as ILayout}>{props.children}</LayoutProvider>
-);
-
-const defaultResponse = {
-  ok: true,
-  status: 200,
-  json: () => Promise.resolve(null),
-};
-
-function mockFetch(
-  method: string = 'GET',
-  result: any = { message: 'ok' },
-  overrideResponse: Partial<typeof defaultResponse> = {}
-) {
-  const endpoint = '/endpoint';
-  const url = `${getLocalApiUrl(endpoint)}?locale=en&market=ww`;
-  const payload = { data: 'data' };
-  const response = {
-    ...defaultResponse,
-    ...overrideResponse,
-    json: () => Promise.resolve(result),
-  } as Response;
-  global.fetch = vi.fn(() =>
-    Promise.resolve(response)
-  );
-  const request: {
-    body?: string;
-    headers: { [key: string]: string },
-    method: string;
-  } = {
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    method,
-  };
-  if (['POST', 'PATCH', 'PUT'].includes(method)) {
-    request.body = JSON.stringify(payload);
-  }
-  return { endpoint, url, payload, result, request, response };
-}
-
-describe('useApi', () => {
-  const ENV = process.env;
-  const FETCH = global.fetch;
-
-  beforeEach(() => {
-    vi.resetModules();
-    vi.resetAllMocks();
-    vi.spyOn(console, 'error').mockImplementation(() => { });
-    vi.spyOn(console, 'log').mockImplementation(() => { });
-    process.env = {
-      MIXER_SECRET: 'MIXER_SECRET_32_CHARS_LONG_12345',
-      NEXT_PUBLIC_API: '/api',
-      NEXT_PUBLIC_MOCK_FALLBACK_URL: 'http://localhost:3000',
-      NEXT_PUBLIC_URL: 'http://localhost:3000',
-      NODE_ENV: 'test',
-      STORE_API_KEY: 'STORE_API_KEY',
-      STORE_API: '/bowl/api',
-      STORE_STRATEGY: 'mock',
-      STORE_URL: 'http://localhost:4000',
-    };
-  });
-
-  afterAll(() => {
-    process.env = ENV;
-    global.fetch = FETCH;
-  });
-
-  test('should throw without provider', () => {
-    expect(() => {
-      renderHook(() => useApi());
-    }).toThrow('useGenericContext must be used within a Provider');
-  });
-
-  test('should not throw with provider', () => {
-    expect(() => {
-      renderHook(() => useApi(), { wrapper });
-    }).not.toThrow();
-  });
-
-  test('api.get should return ok', async () => {
-    const { result } = renderHook(() => useApi(), { wrapper });
-    const mock = mockFetch();
-    const response = await result.current.get(mock.endpoint);
-    expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch).toHaveBeenCalledWith(mock.url, mock.request);
-    expect(response).toBe(mock.result);
-  });
-
-  test('api.post should return ok', async () => {
-    const { result } = renderHook(() => useApi(), { wrapper });
-    const mock = mockFetch('POST');
-    const response = await result.current.post(mock.endpoint, mock.payload);
-    expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch).toHaveBeenCalledWith(mock.url, mock.request);
-    expect(response).toBe(mock.result);
-  });
-
-  test('api.patch should return ok', async () => {
-    const { result } = renderHook(() => useApi(), { wrapper });
-    const mock = mockFetch('PATCH');
-    const response = await result.current.patch(mock.endpoint, mock.payload);
-    expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch).toHaveBeenCalledWith(mock.url, mock.request);
-    expect(response).toBe(mock.result);
-  });
-
-  test('api.put should return ok', async () => {
-    const { result } = renderHook(() => useApi(), { wrapper });
-    const mock = mockFetch('PUT');
-    const response = await result.current.put(mock.endpoint, mock.payload);
-    expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch).toHaveBeenCalledWith(mock.url, mock.request);
-    expect(response).toBe(mock.result);
-  });
-
-  test('api.delete should return ok', async () => {
-    const { result } = renderHook(() => useApi(), { wrapper });
-    const mock = mockFetch('DELETE');
-    const response = await result.current.delete(mock.endpoint);
-    expect(fetch).toHaveBeenCalledTimes(1);
-    expect(fetch).toHaveBeenCalledWith(mock.url, mock.request);
-    expect(response).toBe(mock.result);
-  });
-
-  test('useApiGet expect result ok', TestMethod('GET'));
-
-  test('useApiPost expect result ok', TestMethod('POST'));
-
-  test('useApiPatch expect result ok', TestMethod('PATCH'));
-
-  test('useApiPut expect result ok', TestMethod('PUT'));
-
-  test('useApiDelete expect result ok', TestMethod('DELETE'));
-
-  function TestMethod(method?: string) {
-    const useHook = (mock: ReturnType<typeof mockFetch>) => {
-      switch (method) {
-        case 'GET':
-          // eslint-disable-next-line react-hooks/rules-of-hooks
-          return useApiGet(mock.endpoint);
-        case 'POST':
-          // eslint-disable-next-line react-hooks/rules-of-hooks
-          return useApiPost(mock.endpoint, mock.payload);
-        case 'PATCH':
-          // eslint-disable-next-line react-hooks/rules-of-hooks
-          return useApiPatch(mock.endpoint, mock.payload);
-        case 'PUT':
-          // eslint-disable-next-line react-hooks/rules-of-hooks
-          return useApiPut(mock.endpoint, mock.payload);
-        case 'DELETE':
-          // eslint-disable-next-line react-hooks/rules-of-hooks
-          return useApiDelete(mock.endpoint);
-        default:
-          // eslint-disable-next-line react-hooks/rules-of-hooks
-          return useApiFetch(mock.endpoint);
-      }
-    };
-    return async () => {
-      const mock = mockFetch(method);
-      const Wrapper = () => {
-        const [response, loading, error, setError] = useHook(mock);
-        return (
-          <>
-            {loading && <div data-testid="loading">loading</div>}
-            {response && <div data-testid="result">{JSON.stringify(response)}</div>}
-            {error && <div data-testid="error">{JSON.stringify(error)}</div>}
-          </>
-        );
-      };
-      render(
-        <LayoutProvider layout={LayoutDefaults as ILayout}><Wrapper /></LayoutProvider>
-      );
-      expect(screen.getByTestId('loading')).toHaveTextContent('loading');
-      await waitForElementToBeRemoved(() => screen.getByTestId('loading'));
-      expect(fetch).toHaveBeenCalledTimes(1);
-      expect(fetch).toHaveBeenCalledWith(mock.url, mock.request);
-      const result = await waitFor(() => screen.getByTestId('result'));
-      expect(result).toHaveTextContent(JSON.stringify(mock.result));
-    };
-  }
-
-});
-
+import { render, renderHook, screen, waitFor, waitForElementToBeRemoved } from '@testing-library/react';
+import { ILayout } from '@websolutespa/bom-core';
+import { getLocalApiUrl } from '@websolutespa/bom-mixer-store';
+import { afterAll, beforeEach, describe, expect, test, vi } from 'vitest';
+import { LayoutProvider } from '../useLayout/useLayout';
+import { LayoutDefaults } from '../useLayout/useLayout.default';
+import { useApi, useApiDelete, useApiFetch, useApiGet, useApiPatch, useApiPost, useApiPut } from './useApi';
+
+const wrapper = (props: { children: React.ReactNode }) => (
+  <LayoutProvider layout={LayoutDefaults as ILayout}>{props.children}</LayoutProvider>
+);
+
+const defaultResponse = {
+  ok: true,
+  status: 200,
+  json: () => Promise.resolve(null),
+};
+
+function mockFetch(
+  method: string = 'GET',
+  result: any = { message: 'ok' },
+  overrideResponse: Partial<typeof defaultResponse> = {}
+) {
+  const endpoint = '/endpoint';
+  const url = `${getLocalApiUrl(endpoint)}?locale=en&market=ww`;
+  const payload = { data: 'data' };
+  const response = {
+    ...defaultResponse,
+    ...overrideResponse,
+    json: () => Promise.resolve(result),
+  } as Response;
+  global.fetch = vi.fn(() =>
+    Promise.resolve(response)
+  );
+  const request: {
+    body?: string;
+    headers: { [key: string]: string },
+    method: string;
+  } = {
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    method,
+  };
+  if (['POST', 'PATCH', 'PUT'].includes(method)) {
+    request.body = JSON.stringify(payload);
+  }
+  return { endpoint, url, payload, result, request, response };
+}
+
+describe('useApi', () => {
+  const ENV = process.env;
+  const FETCH = global.fetch;
+
+  beforeEach(() => {
+    vi.resetModules();
+    vi.resetAllMocks();
+    vi.spyOn(console, 'error').mockImplementation(() => { });
+    vi.spyOn(console, 'log').mockImplementation(() => { });
+    process.env = {
+      MIXER_SECRET: 'MIXER_SECRET_32_CHARS_LONG_12345',
+      NEXT_PUBLIC_API: '/api',
+      NEXT_PUBLIC_MOCK_FALLBACK_URL: 'http://localhost:3000',
+      NEXT_PUBLIC_URL: 'http://localhost:3000',
+      NODE_ENV: 'test',
+      STORE_API_KEY: 'STORE_API_KEY',
+      STORE_API: '/bowl/api',
+      STORE_STRATEGY: 'mock',
+      STORE_URL: 'http://localhost:4000',
+    };
+  });
+
+  afterAll(() => {
+    process.env = ENV;
+    global.fetch = FETCH;
+  });
+
+  test('should throw without provider', () => {
+    expect(() => {
+      renderHook(() => useApi());
+    }).toThrow('useGenericContext must be used within a Provider');
+  });
+
+  test('should not throw with provider', () => {
+    expect(() => {
+      renderHook(() => useApi(), { wrapper });
+    }).not.toThrow();
+  });
+
+  test('api.get should return ok', async () => {
+    const { result } = renderHook(() => useApi(), { wrapper });
+    const mock = mockFetch();
+    const response = await result.current.get(mock.endpoint);
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(fetch).toHaveBeenCalledWith(mock.url, mock.request);
+    expect(response).toBe(mock.result);
+  });
+
+  test('api.post should return ok', async () => {
+    const { result } = renderHook(() => useApi(), { wrapper });
+    const mock = mockFetch('POST');
+    const response = await result.current.post(mock.endpoint, mock.payload);
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(fetch).toHaveBeenCalledWith(mock.url, mock.request);
+    expect(response).toBe(mock.result);
+  });
+
+  test('api.patch should return ok', async () => {
+    const { result } = renderHook(() => useApi(), { wrapper });
+    const mock = mockFetch('PATCH');
+    const response = await result.current.patch(mock.endpoint, mock.payload);
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(fetch).toHaveBeenCalledWith(mock.url, mock.request);
+    expect(response).toBe(mock.result);
+  });
+
+  test('api.put should return ok', async () => {
+    const { result } = renderHook(() => useApi(), { wrapper });
+    const mock = mockFetch('PUT');
+    const response = await result.current.put(mock.endpoint, mock.payload);
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(fetch).toHaveBeenCalledWith(mock.url, mock.request);
+    expect(response).toBe(mock.result);
+  });
+
+  test('api.delete should return ok', async () => {
+    const { result } = renderHook(() => useApi(), { wrapper });
+    const mock = mockFetch('DELETE');
+    const response = await result.current.delete(mock.endpoint);
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect(fetch).toHaveBeenCalledWith(mock.url, mock.request);
+    expect(response).toBe(mock.result);
+  });
+
+  test('useApiGet expect result ok', TestMethod('GET'));
+
+  test('useApiPost expect result ok', TestMethod('POST'));
+
+  test('useApiPatch expect result ok', TestMethod('PATCH'));
+
+  test('useApiPut expect result ok', TestMethod('PUT'));
+
+  test('useApiDelete expect result ok', TestMethod('DELETE'));
+
+  function TestMethod(method?: string) {
+    const useHook = (mock: ReturnType<typeof mockFetch>) => {
+      switch (method) {
+        case 'GET':
+          // eslint-disable-next-line react-hooks/rules-of-hooks
+          return useApiGet(mock.endpoint);
+        case 'POST':
+          // eslint-disable-next-line react-hooks/rules-of-hooks
+          return useApiPost(mock.endpoint, mock.payload);
+        case 'PATCH':
+          // eslint-disable-next-line react-hooks/rules-of-hooks
+          return useApiPatch(mock.endpoint, mock.payload);
+        case 'PUT':
+          // eslint-disable-next-line react-hooks/rules-of-hooks
+          return useApiPut(mock.endpoint, mock.payload);
+        case 'DELETE':
+          // eslint-disable-next-line react-hooks/rules-of-hooks
+          return useApiDelete(mock.endpoint);
+        default:
+          // eslint-disable-next-line react-hooks/rules-of-hooks
+          return useApiFetch(mock.endpoint);
+      }
+    };
+    return async () => {
+      const mock = mockFetch(method);
+      const Wrapper = () => {
+        const [response, loading, error, setError] = useHook(mock);
+        return (
+          <>
+            {loading && <div data-testid="loading">loading</div>}
+            {response && <div data-testid="result">{JSON.stringify(response)}</div>}
+            {error && <div data-testid="error">{JSON.stringify(error)}</div>}
+          </>
+        );
+      };
+      render(
+        <LayoutProvider layout={LayoutDefaults as ILayout}><Wrapper /></LayoutProvider>
+      );
+      expect(screen.getByTestId('loading')).toHaveTextContent('loading');
+      await waitForElementToBeRemoved(() => screen.getByTestId('loading'));
+      expect(fetch).toHaveBeenCalledTimes(1);
+      expect(fetch).toHaveBeenCalledWith(mock.url, mock.request);
+      const result = await waitFor(() => screen.getByTestId('result'));
+      expect(result).toHaveTextContent(JSON.stringify(mock.result));
+    };
+  }
+
+});
+