@dotcms/client 1.0.1 → 1.0.2

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

@@ -1,197 +0,0 @@
-import consola from 'consola';
-
-import {
-    DotCMSClientConfig,
-    DotCMSComposedPageResponse,
-    DotCMSExtendedPageResponse,
-    DotCMSPageResponse,
-    DotCMSPageRequestParams,
-    RequestOptions
-} from '@dotcms/types';
-
-import { buildPageQuery, buildQuery, fetchGraphQL, mapResponseData } from './utils';
-
-import { graphqlToPageEntity } from '../../utils';
-
-/**
- * Client for interacting with the DotCMS Page API.
- * Provides methods to retrieve and manipulate pages.
- */
-export class PageClient {
-    /**
-     * Request options including authorization headers.
-     * @private
-     */
-    private requestOptions: RequestOptions;
-
-    /**
-     * Site ID for page requests.
-     * @private
-     */
-    private siteId: string;
-
-    /**
-     * DotCMS URL for page requests.
-     * @private
-     */
-    private dotcmsUrl: string;
-
-    /**
-     * Creates a new PageClient instance.
-     *
-     * @param {DotCMSClientConfig} config - Configuration options for the DotCMS client
-     * @param {RequestOptions} requestOptions - Options for fetch requests including authorization headers
-     * @example
-     * ```typescript
-     * const pageClient = new PageClient(
-     *   {
-     *     dotcmsUrl: 'https://demo.dotcms.com',
-     *     authToken: 'your-auth-token',
-     *     siteId: 'demo.dotcms.com'
-     *   },
-     *   {
-     *     headers: {
-     *       Authorization: 'Bearer your-auth-token'
-     *     }
-     *   }
-     * );
-     * ```
-     */
-    constructor(config: DotCMSClientConfig, requestOptions: RequestOptions) {
-        this.requestOptions = requestOptions;
-        this.siteId = config.siteId || '';
-        this.dotcmsUrl = config.dotcmsUrl;
-    }
-
-    /**
-     * Retrieves a page from DotCMS using GraphQL.
-     *
-     * @param {string} url - The URL of the page to retrieve
-     * @param {DotCMSPageRequestParams} [options] - Options for the request
-     * @template T - The type of the page and content, defaults to DotCMSBasicPage and Record<string, unknown> | unknown
-     * @returns {Promise<DotCMSComposedPageResponse<T>>} A Promise that resolves to the page data
-     *
-     * @example Using GraphQL
-     * ```typescript
-     * const page = await pageClient.get<{ page: MyPageWithBanners; content: { blogPosts: { blogTitle: string } } }>(
-     *     '/index',
-     *     {
-     *         languageId: '1',
-     *         mode: 'LIVE',
-     *         graphql: {
-     *             page: `
-     *              containers {
-     *                  containerContentlets {
-     *                      contentlets {
-     *                          ... on 	Banner {
-     *                              ...bannerFragment
-     *                          }
-     *                      }
-     *                  }
-     *              `,
-     *              content: {
-     *                  blogPosts: `
-     *                      BlogCollection(limit: 3) {
-     *                          ...blogFragment
-     *                      }
-     *                  `,
-     *              },
-     *              fragments: [
-     *                  `
-     *                      fragment bannerFragment on Banner {
-     *                          caption
-     *                      }
-     *                  `,
-     *                  `
-     *                      fragment blogFragment on Blog {
-     *                          title
-     *                          urlTitle
-     *                      }
-     *                  `
-     *              ]
-     *          }
-     *      });
-     * ```
-     */
-    async get<T extends DotCMSExtendedPageResponse = DotCMSPageResponse>(
-        url: string,
-        options?: DotCMSPageRequestParams
-    ): Promise<DotCMSComposedPageResponse<T>> {
-        const {
-            languageId = '1',
-            mode = 'LIVE',
-            siteId = this.siteId,
-            fireRules = false,
-            personaId,
-            publishDate,
-            variantName,
-            graphql = {}
-        } = options || {};
-        const { page, content = {}, variables, fragments } = graphql;
-
-        const contentQuery = buildQuery(content);
-        const completeQuery = buildPageQuery({
-            page,
-            fragments,
-            additionalQueries: contentQuery
-        });
-
-        const requestVariables: Record<string, unknown> = {
-            // The url is expected to have a leading slash to comply on VanityURL Matching, some frameworks like Angular will not add the leading slash
-            url: url.startsWith('/') ? url : `/${url}`,
-            mode,
-            languageId,
-            personaId,
-            fireRules,
-            publishDate,
-            siteId,
-            variantName,
-            ...variables
-        };
-
-        const requestHeaders = this.requestOptions.headers as Record<string, string>;
-        const requestBody = JSON.stringify({ query: completeQuery, variables: requestVariables });
-
-        try {
-            const { data, errors } = await fetchGraphQL({
-                baseURL: this.dotcmsUrl,
-                body: requestBody,
-                headers: requestHeaders
-            });
-
-            if (errors) {
-                errors.forEach((error: { message: string }) => {
-                    consola.error('[DotCMS GraphQL Error]: ', error.message);
-                });
-            }
-
-            const pageResponse = graphqlToPageEntity(data);
-
-            if (!pageResponse) {
-                throw new Error('No page data found');
-            }
-
-            const contentResponse = mapResponseData(data, Object.keys(content));
-
-            return {
-                pageAsset: pageResponse,
-                content: contentResponse,
-                graphql: {
-                    query: completeQuery,
-                    variables: requestVariables
-                }
-            };
-        } catch (error) {
-            const errorMessage = {
-                error,
-                message: 'Failed to retrieve page data',
-                graphql: {
-                    query: completeQuery,
-                    variables: requestVariables
-                }
-            };
-
-            throw errorMessage;
-        }
-    }
-}

package/src/lib/client/page/utils.ts

@@ -1,291 +0,0 @@
-import { consola } from 'consola';
-
-import { ErrorMessages } from '../models';
-
-const DEFAULT_PAGE_CONTENTLETS_CONTENT = `
-          publishDate
-          inode
-          identifier
-          archived
-          urlMap
-          urlMap
-          locked
-          contentType
-          creationDate
-          modDate
-          title
-          baseType
-          working
-          live
-          publishUser {
-            firstName
-            lastName
-          }
-          owner {
-            lastName
-          }
-          conLanguage {
-            language
-            languageCode
-          }
-          modUser {
-            firstName
-            lastName
-          }
-`;
-
-/**
- * Builds a GraphQL query for retrieving page content from DotCMS.
- *
- * @param {string} pageQuery - Custom fragment fields to include in the ClientPage fragment
- * @param {string} additionalQueries - Additional GraphQL queries to include in the main query
- * @returns {string} Complete GraphQL query string for page content
- */
-export const buildPageQuery = ({
-    page,
-    fragments,
-    additionalQueries
-}: {
-    page?: string;
-    fragments?: string[];
-    additionalQueries?: string;
-}) => {
-    if (!page) {
-        consola.warn(
-            "[DotCMS Client]: No page query was found, so we're loading all content using _map. This might slow things down. For better performance, we recommend adding a specific query in the page attribute."
-        );
-    }
-
-    return `
-  fragment DotCMSPage on DotPage {
-    publishDate
-    type
-    httpsRequired
-    inode
-    path
-    identifier
-    hasTitleImage
-    sortOrder
-    extension
-    canRead
-    pageURI
-    canEdit
-    archived
-    friendlyName
-    workingInode
-    url
-    pageURI
-    hasLiveVersion
-    deleted
-    pageUrl
-    shortyWorking
-    mimeType
-    locked
-    stInode
-    contentType
-    creationDate
-    liveInode
-    name
-    shortyLive
-    modDate
-    title
-    baseType
-    working
-    canLock
-    live
-    isContentlet
-    statusIcons
-    canEdit
-    canLock
-    canRead
-    canEdit
-    canLock
-    canRead
-    runningExperimentId
-    urlContentMap {
-      _map
-    }
-    host {
-      identifier
-      hostName
-     	googleMap
-      archived
-      contentType
-    }
-    vanityUrl {
-      action
-      forwardTo
-      uri
-    }
-    conLanguage {
-      id
-      language
-      languageCode
-    }
-    template {
-      drawed
-      anonymous
-      theme
-      identifier
-    }
-    containers {
-      path
-      identifier
-      maxContentlets
-      containerStructures {
-        id
-        code
-        structureId
-        containerId
-        contentTypeVar
-        containerInode
-      }
-      containerContentlets {
-        uuid
-        contentlets {
-          ${page ? DEFAULT_PAGE_CONTENTLETS_CONTENT : '_map'}
-        }
-      }
-    }
-    layout {
-      header
-      footer
-      body {
-        rows {
-          styleClass
-          columns {
-            leftOffset
-            styleClass
-            width
-            left
-            containers {
-              identifier
-              uuid
-            }
-          }
-        }
-      }
-    }
-    viewAs {
-      visitor {
-        persona {
-          modDate
-          inode
-          name
-          identifier
-          keyTag
-          photo {
-            versionPath
-          }
-        }
-      }
-      persona {
-        modDate
-        inode
-        name
-        identifier
-        keyTag
-        photo {
-         versionPath
-        }
-      }
-      language {
-        id
-        languageCode
-        countryCode
-        language
-        country
-      }
-    }
-  }
-
-  ${page ? ` fragment ClientPage on DotPage { ${page} } ` : ''}
-
-  ${fragments ? fragments.join('\n\n') : ''}
-
-  query PageContent($url: String!, $languageId: String, $mode: String, $personaId: String, $fireRules: Boolean, $publishDate: String, $siteId: String, $variantName: String) {
-    page: page(url: $url, languageId: $languageId, pageMode: $mode, persona: $personaId, fireRules: $fireRules, publishDate: $publishDate, site: $siteId, variantName: $variantName) {
-      ...DotCMSPage
-      ${page ? '...ClientPage' : ''}
-    }
-
-    ${additionalQueries}
-  }
-  `;
-};
-
-/**
- * Converts a record of query strings into a single GraphQL query string.
- *
- * @param {Record<string, string>} queryData - Object containing named query strings
- * @returns {string} Combined query string or empty string if no queryData provided
- */
-export function buildQuery(queryData: Record<string, string>): string {
-    if (!queryData) return '';
-
-    return Object.entries(queryData)
-        .map(([key, query]) => `${key}: ${query}`)
-        .join(' ');
-}
-
-/**
- * Filters response data to include only specified keys.
- *
- * @param {Record<string, string>} responseData - Original response data object
- * @param {string[]} keys - Array of keys to extract from the response data
- * @returns {Record<string, string>} New object containing only the specified keys
- */
-export function mapResponseData(
-    responseData: Record<string, string>,
-    keys: string[]
-): Record<string, string> {
-    return keys.reduce(
-        (accumulator, key) => {
-            if (responseData[key] !== undefined) {
-                accumulator[key] = responseData[key];
-            }
-
-            return accumulator;
-        },
-        {} as Record<string, string>
-    );
-}
-
-/**
- * Executes a GraphQL query against the DotCMS API.
- *
- * @param {Object} options - Options for the fetch request
- * @param {string} options.body - GraphQL query string
- * @param {Record<string, string>} options.headers - HTTP headers for the request
- * @returns {Promise<any>} Parsed JSON response from the GraphQL API
- * @throws {Error} If the HTTP response is not successful
- */
-export async function fetchGraphQL({
-    baseURL,
-    body,
-    headers
-}: {
-    baseURL: string;
-    body: string;
-    headers: Record<string, string>;
-}) {
-    const url = new URL(baseURL);
-    url.pathname = '/api/v1/graphql';
-
-    const response = await fetch(url.toString(), {
-        method: 'POST',
-        body,
-        headers
-    });
-
-    if (!response.ok) {
-        const error = {
-            status: response.status,
-            message: ErrorMessages[response.status] || response.statusText
-        };
-
-        throw error;
-    }
-
-    return await response.json();
-}