@dotcms/client 1.0.1 → 1.0.2

package/src/lib/client/navigation/navigation-api.spec.ts

@@ -1,167 +0,0 @@
-import { DotCMSClientConfig, RequestOptions } from '@dotcms/types';
-
-import { NavigationClient } from './navigation-api';
-
-describe('NavigationClient', () => {
-    const mockFetch = jest.fn();
-    const originalFetch = global.fetch;
-
-    const validConfig: DotCMSClientConfig = {
-        dotcmsUrl: 'https://demo.dotcms.com',
-        authToken: 'test-token',
-        siteId: 'test-site'
-    };
-
-    const requestOptions: RequestOptions = {
-        headers: {
-            Authorization: 'Bearer test-token'
-        }
-    };
-
-    const mockNavigationData = {
-        entity: {
-            title: 'Main Navigation',
-            items: [
-                { label: 'Home', url: '/' },
-                { label: 'About', url: '/about' },
-                { label: 'Contact', url: '/contact' }
-            ]
-        }
-    };
-
-    beforeEach(() => {
-        mockFetch.mockReset();
-        global.fetch = mockFetch;
-        mockFetch.mockResolvedValue({
-            ok: true,
-            json: async () => mockNavigationData
-        });
-    });
-
-    afterAll(() => {
-        global.fetch = originalFetch;
-    });
-
-    it('should fetch navigation successfully', async () => {
-        const navClient = new NavigationClient(validConfig, requestOptions);
-        const result = await navClient.get('/');
-
-        expect(mockFetch).toHaveBeenCalledWith(
-            'https://demo.dotcms.com/api/v1/nav/',
-            requestOptions
-        );
-
-        expect(result).toEqual(mockNavigationData.entity);
-    });
-
-    it('should fetch navigation with custom path', async () => {
-        const navClient = new NavigationClient(validConfig, requestOptions);
-        const path = '/products';
-
-        await navClient.get(path);
-
-        expect(mockFetch).toHaveBeenCalledWith(
-            'https://demo.dotcms.com/api/v1/nav/products',
-            expect.anything()
-        );
-    });
-
-    it('should fetch navigation with custom depth', async () => {
-        const navClient = new NavigationClient(validConfig, requestOptions);
-        const depth = 3;
-
-        await navClient.get('/', { depth });
-
-        expect(mockFetch).toHaveBeenCalledWith(
-            'https://demo.dotcms.com/api/v1/nav/?depth=3',
-            expect.anything()
-        );
-    });
-
-    it('should normalize path by removing leading slash', async () => {
-        const navClient = new NavigationClient(validConfig, requestOptions);
-
-        await navClient.get('/about/');
-
-        expect(mockFetch).toHaveBeenCalledWith(
-            'https://demo.dotcms.com/api/v1/nav/about/',
-            expect.anything()
-        );
-    });
-
-    it('should handle root path correctly', async () => {
-        const navClient = new NavigationClient(validConfig, requestOptions);
-
-        await navClient.get('/');
-
-        expect(mockFetch).toHaveBeenCalledWith(
-            'https://demo.dotcms.com/api/v1/nav/',
-            expect.anything()
-        );
-    });
-
-    it('should handle fetch errors', async () => {
-        mockFetch.mockRejectedValue(new Error('Network error'));
-
-        const navClient = new NavigationClient(validConfig, requestOptions);
-
-        await expect(navClient.get('/')).rejects.toThrow('Network error');
-    });
-
-    it('should handle non-OK responses', async () => {
-        mockFetch.mockResolvedValue({
-            ok: false,
-            status: 404,
-            statusText: 'Not Found'
-        });
-
-        const navClient = new NavigationClient(validConfig, requestOptions);
-
-        await expect(navClient.get('/')).rejects.toThrow(
-            `Failed to fetch navigation data: Not Found - 404`
-        );
-    });
-
-    it('should include authorization headers in request', async () => {
-        const navClient = new NavigationClient(validConfig, requestOptions);
-
-        await navClient.get('/');
-
-        expect(mockFetch).toHaveBeenCalledWith(
-            expect.any(String),
-            expect.objectContaining({
-                headers: expect.objectContaining({
-                    Authorization: 'Bearer test-token'
-                })
-            })
-        );
-    });
-
-    it('should merge additional request options', async () => {
-        const optionsWithCache: RequestOptions = {
-            ...requestOptions,
-            cache: 'no-cache',
-            credentials: 'include'
-        };
-
-        const navClient = new NavigationClient(validConfig, optionsWithCache);
-
-        await navClient.get('/');
-
-        expect(mockFetch).toHaveBeenCalledWith(
-            'https://demo.dotcms.com/api/v1/nav/',
-            optionsWithCache
-        );
-    });
-
-    it('should fetch navigation with multiple options', async () => {
-        const navClient = new NavigationClient(validConfig, requestOptions);
-
-        await navClient.get('/', { depth: 3, languageId: 2 });
-
-        expect(mockFetch).toHaveBeenCalledWith(
-            'https://demo.dotcms.com/api/v1/nav/?depth=3&language_id=2',
-            requestOptions
-        );
-    });
-});

package/src/lib/client/navigation/navigation-api.ts

@@ -1,62 +0,0 @@
-import {
-    DotCMSClientConfig,
-    DotCMSNavigationRequestParams,
-    RequestOptions,
-    DotCMSNavigationItem
-} from '@dotcms/types';
-
-export class NavigationClient {
-    private requestOptions: RequestOptions;
-
-    private BASE_URL: string;
-
-    constructor(config: DotCMSClientConfig, requestOptions: RequestOptions) {
-        this.requestOptions = requestOptions;
-        this.BASE_URL = `${config?.dotcmsUrl}/api/v1/nav`;
-    }
-
-    /**
-     * Retrieves information about the dotCMS file and folder tree.
-     * @param {NavigationApiOptions} options - The options for the Navigation API call. Defaults to `{ depth: 0, path: '/', languageId: 1 }`.
-     * @returns {Promise<DotCMSNavigationItem[]>} - A Promise that resolves to the response from the DotCMS API.
-     * @throws {Error} - Throws an error if the options are not valid.
-     */
-    async get(
-        path: string,
-        params?: DotCMSNavigationRequestParams
-    ): Promise<DotCMSNavigationItem[]> {
-        if (!path) {
-            throw new Error("The 'path' parameter is required for the Navigation API");
-        }
-
-        const navParams = params ? this.mapToBackendParams(params) : {};
-        const urlParams = new URLSearchParams(navParams).toString();
-
-        const parsedPath = path.replace(/^\/+/, '/').replace(/\/+$/, '/');
-        const url = `${this.BASE_URL}${parsedPath}${urlParams ? `?${urlParams}` : ''}`;
-
-        const response = await fetch(url, this.requestOptions);
-
-        if (!response.ok) {
-            throw new Error(
-                `Failed to fetch navigation data: ${response.statusText} - ${response.status}`
-            );
-        }
-
-        return response.json().then((data) => data.entity);
-    }
-
-    private mapToBackendParams(params: DotCMSNavigationRequestParams): Record<string, string> {
-        const backendParams: Record<string, string> = {};
-
-        if (params.depth) {
-            backendParams['depth'] = String(params.depth);
-        }
-
-        if (params.languageId) {
-            backendParams['language_id'] = String(params.languageId);
-        }
-
-        return backendParams;
-    }
-}

package/src/lib/client/page/page-api.spec.ts

@@ -1,359 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-jest.mock('consola');
-
-import * as consola from 'consola';
-
-import {
-    DotCMSClientConfig,
-    DotCMSPageRequestParams,
-    RequestOptions,
-    DotCMSGraphQLPageResponse,
-    DotCMSPageResponse
-} from '@dotcms/types';
-
-import { PageClient } from './page-api';
-import * as utils from './utils';
-
-import { graphqlToPageEntity } from '../../utils';
-
-describe('PageClient', () => {
-    const mockFetchGraphQL = jest.fn();
-
-    const validConfig: DotCMSClientConfig = {
-        dotcmsUrl: 'https://demo.dotcms.com',
-        authToken: 'test-token',
-        siteId: 'test-site'
-    };
-
-    const requestOptions: RequestOptions = {
-        headers: {
-            Authorization: 'Bearer test-token'
-        }
-    };
-
-    const mockGraphQLResponse = {
-        data: {
-            page: {
-                title: 'GraphQL Page',
-                url: '/graphql-page'
-            },
-            testContent: {
-                items: [{ title: 'Content Item' }]
-            },
-            testNav: {
-                items: [{ label: 'Nav Item', url: '/nav' }]
-            }
-        },
-        errors: null
-    };
-
-    beforeEach(() => {
-        mockFetchGraphQL.mockReset();
-        global.console.error = jest.fn(); // Mock console.error to prevent actual errors from being logged in the console when running tests
-
-        jest.spyOn(utils, 'fetchGraphQL').mockImplementation(mockFetchGraphQL);
-        mockFetchGraphQL.mockResolvedValue(mockGraphQLResponse);
-
-        jest.spyOn(utils, 'buildPageQuery').mockReturnValue('mock-page-query');
-        jest.spyOn(utils, 'buildQuery').mockReturnValue('mock-query');
-        jest.spyOn(utils, 'mapResponseData').mockImplementation((data, keys) => {
-            const result: Record<string, any> = {};
-
-            keys.forEach((key) => {
-                result[key] = data[`test${key.charAt(0).toUpperCase() + key.slice(1)}`];
-            });
-
-            return result;
-        });
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    describe('GraphQL API', () => {
-        it('should fetch page using GraphQL when query option is provided', async () => {
-            const pageClient = new PageClient(validConfig, requestOptions);
-
-            const graphQLOptions: DotCMSPageRequestParams = {
-                graphql: {
-                    page: `containers {
-      containerContentlets {
-        contentlets {
-         ... on Banner {
-            title
-          }
-        }
-      }
-    }`,
-                    content: { content: 'query Content { items { title } }' }
-                },
-                languageId: '1',
-                mode: 'LIVE'
-            };
-
-            const result = await pageClient.get('/graphql-page', graphQLOptions);
-
-            expect(utils.buildPageQuery).toHaveBeenCalled();
-            expect(utils.buildQuery).toHaveBeenCalledTimes(1);
-            expect(utils.fetchGraphQL).toHaveBeenCalledWith({
-                body: expect.any(String),
-                headers: requestOptions.headers,
-                baseURL: 'https://demo.dotcms.com'
-            });
-
-            expect(result).toEqual({
-                pageAsset: graphqlToPageEntity(
-                    mockGraphQLResponse.data as unknown as DotCMSGraphQLPageResponse
-                ),
-                content: { content: mockGraphQLResponse.data.testContent },
-                graphql: {
-                    query: expect.any(String),
-                    variables: expect.any(Object)
-                },
-                vanityUrl: undefined,
-                runningExperimentId: undefined
-            });
-        });
-
-        it('should print graphql errors ', async () => {
-            const consolaSpy = jest.spyOn(consola, 'error');
-            const pageClient = new PageClient(validConfig, requestOptions);
-            const graphQLOptions = {
-                graphql: {
-                    page: `containers {
-                        containerContentlets {
-                            contentlets {
-                                ... on Banner {
-                                    title
-                                }
-                            }
-                        }
-                    }`,
-                    content: { content: 'query Content { items { title } }' }
-                }
-            };
-
-            mockFetchGraphQL.mockResolvedValue({
-                data: {
-                    page: {
-                        title: 'GraphQL Page'
-                    }
-                },
-                errors: [{ message: 'Some internal server error' }]
-            });
-
-            await pageClient.get('/graphql-page', graphQLOptions);
-
-            expect(consolaSpy).toHaveBeenCalledWith(
-                '[DotCMS GraphQL Error]: ',
-                'Some internal server error'
-            );
-        });
-
-        it('should return an error if the page is not found', async () => {
-            const pageClient = new PageClient(validConfig, requestOptions);
-            const graphQLOptions = {
-                graphql: {
-                    page: `containers {
-                        containerContentlets {
-                            contentlets {
-                                ... on Banner {
-                                    title
-                                }
-                            }
-                        }
-                    }`,
-                    content: { content: 'query Content { items { title } }' }
-                }
-            };
-
-            mockFetchGraphQL.mockResolvedValue({
-                data: {
-                    page: null
-                },
-                errors: [{ message: 'No page data found' }]
-            });
-
-            try {
-                await pageClient.get('/graphql-page', graphQLOptions);
-            } catch (response: unknown) {
-                const responseData = response as DotCMSPageResponse;
-
-                expect(responseData.error?.message).toBe('No page data found');
-            }
-        });
-
-        it('should add leading slash to url if it does not have it', async () => {
-            const pageClient = new PageClient(validConfig, requestOptions);
-            const graphQLOptions = {
-                graphql: {
-                    page: `containers {
-                        containerContentlets {
-                            contentlets {
-                                ... on Banner {
-                                    title
-                                }
-                            }
-                        }
-                    }`,
-                    content: { content: 'query Content { items { title } }' }
-                }
-            };
-
-            // No leading slash
-            const result = await pageClient.get('graphql-page', graphQLOptions as any);
-
-            expect(result).toEqual({
-                pageAsset: graphqlToPageEntity(
-                    mockGraphQLResponse.data as unknown as DotCMSGraphQLPageResponse
-                ),
-                content: { content: mockGraphQLResponse.data.testContent },
-                graphql: {
-                    query: expect.any(String),
-                    variables: expect.objectContaining({
-                        url: '/graphql-page'
-                    })
-                },
-                vanityUrl: undefined,
-                runningExperimentId: undefined
-            });
-        });
-
-        it('should pass correct variables to GraphQL query', async () => {
-            const pageClient = new PageClient(validConfig, requestOptions);
-            const graphQLOptions = {
-                graphql: {
-                    page: `containers {
-      containerContentlets {
-        contentlets {
-         ... on Banner {
-            title
-          }
-        }
-      }
-    }`,
-                    content: { content: 'query Content { items { title } }' }
-                },
-                languageId: '2',
-                mode: 'PREVIEW_MODE'
-            };
-
-            await pageClient.get('/custom-page', graphQLOptions as any);
-
-            const requestBody = JSON.parse(mockFetchGraphQL.mock.calls[0][0].body);
-            expect(requestBody.variables).toEqual({
-                url: '/custom-page',
-                mode: 'PREVIEW_MODE',
-                languageId: '2',
-                fireRules: false,
-                siteId: 'test-site'
-            });
-        });
-
-        it('should handle GraphQL errors', async () => {
-            mockFetchGraphQL.mockRejectedValue(new Error('GraphQL error'));
-
-            const pageClient = new PageClient(validConfig, requestOptions);
-            const graphQLOptions = {
-                graphql: {
-                    page: `containers {
-      containerContentlets {
-        contentlets {
-         ... on Banner {
-            title
-          }
-        }
-      }
-    }`,
-                    content: { content: 'query Content { items { title } }' }
-                }
-            };
-            try {
-                await pageClient.get('/page', graphQLOptions);
-            } catch (error: any) {
-                expect(error.message).toBe('Failed to retrieve page data');
-            }
-        });
-
-        it('should throw errors from GraphQL', async () => {
-            mockFetchGraphQL.mockResolvedValue({
-                errors: [{ message: 'GraphQL error' }]
-            });
-
-            const pageClient = new PageClient(validConfig, requestOptions);
-            const graphQLOptions = {
-                graphql: {
-                    page: `containers {
-      containerContentlets {
-        contentlets {
-         ... on Banner {
-            title
-          }
-        }`,
-                    content: { content: 'query Content { items { title } }' }
-                }
-            };
-            try {
-                await pageClient.get('/page', graphQLOptions);
-            } catch (error: any) {
-                expect(error.message).toBe('Failed to retrieve page data');
-            }
-        });
-
-        it('should use default values for languageId and mode if not provided', async () => {
-            const pageClient = new PageClient(validConfig, requestOptions);
-            const graphQLOptions = {
-                graphql: {
-                    page: `containers {
-      containerContentlets {
-        contentlets {
-         ... on Banner {
-            title
-          }
-        }`,
-                    content: { content: 'query Content { items { title } }' }
-                }
-            };
-            await pageClient.get('/default-page', graphQLOptions);
-
-            const requestBody = JSON.parse(mockFetchGraphQL.mock.calls[0][0].body);
-            expect(requestBody.variables).toEqual({
-                url: '/default-page',
-                mode: 'LIVE',
-                languageId: '1',
-                fireRules: false,
-                siteId: 'test-site'
-            });
-        });
-
-        it('should fetch using graphQL even if there is no graphql option', async () => {
-            const pageClient = new PageClient(validConfig, requestOptions);
-
-            await pageClient.get('/why-obi-wan-had-the-high-ground');
-
-            expect(mockFetchGraphQL).toHaveBeenCalled();
-            expect(utils.buildPageQuery).toHaveBeenCalled();
-            expect(utils.buildQuery).toHaveBeenCalledTimes(1);
-            expect(utils.fetchGraphQL).toHaveBeenCalledWith({
-                body: expect.stringContaining('"url":"/why-obi-wan-had-the-high-ground"'),
-                headers: requestOptions.headers,
-                baseURL: 'https://demo.dotcms.com'
-            });
-        });
-    });
-
-    describe('Client initialization', () => {
-        it('should use siteId from config when not provided in params', async () => {
-            const pageClient = new PageClient(validConfig, requestOptions);
-
-            await pageClient.get('/test-page');
-
-            expect(mockFetchGraphQL).toHaveBeenCalledWith({
-                baseURL: 'https://demo.dotcms.com',
-                body: expect.stringContaining('"siteId":"test-site"'),
-                headers: requestOptions.headers
-            });
-        });
-    });
-});