@dotcms/client 0.0.1-beta.9 → 1.0.0

package/next.esm.js

@@ -1,551 +0,0 @@
-import { E as ErrorMessages, _ as __classPrivateFieldGet, g as graphqlToPageEntity, C as Content } from './transforms.esm.js';
-
-class NavigationClient {
-    constructor(config, 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<unknown>} - 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, params) {
-        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);
-    }
-    mapToBackendParams(params) {
-        const backendParams = {};
-        if (params.depth) {
-            backendParams['depth'] = String(params.depth);
-        }
-        if (params.languageId) {
-            backendParams['language_id'] = String(params.languageId);
-        }
-        return backendParams;
-    }
-}
-
-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
- */
-const buildPageQuery = ({ page, fragments, additionalQueries }) => {
-    if (!page) {
-        console.warn('No page query provided. The query will be used by fetching all content with _map. This may mean poor performance in the query. We suggest you provide a detailed query on page attribute.');
-    }
-    return `
-  fragment DotCMSPage on DotPage {
-    publishDate
-    type
-    httpsRequired
-    inode
-    path
-    identifier
-    hasTitleImage
-    sortOrder
-    extension
-    canRead
-    pageURI
-    canEdit
-    archived
-    friendlyName
-    workingInode
-    url
-    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
-    conLanguage {
-      id
-      language
-      languageCode
-    }
-    template {
-      drawed
-    }
-    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 {
-          columns {
-            leftOffset
-            styleClass
-            width
-            left
-            containers {
-              identifier
-              uuid
-            }
-          }
-        }
-      }
-    }
-    viewAs {
-      visitor {
-        persona {
-          name
-        }
-      }
-      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) {
-    page: page(url: $url, languageId: $languageId, pageMode: $mode) {
-      ...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
- */
-function buildQuery(queryData) {
-    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
- */
-function mapResponseData(responseData, keys) {
-    return keys.reduce((accumulator, key) => {
-        if (responseData[key] !== undefined) {
-            accumulator[key] = responseData[key];
-        }
-        return accumulator;
-    }, {});
-}
-/**
- * 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
- */
-async function fetchGraphQL({ baseURL, body, headers }) {
-    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();
-}
-
-var _PageClient_instances, _PageClient_isGraphQLRequest, _PageClient_getPageFromAPI, _PageClient_getPageFromGraphQL, _PageClient_mapToBackendParams;
-/**
- * Client for interacting with the DotCMS Page API.
- * Provides methods to retrieve and manipulate pages.
- */
-class PageClient {
-    /**
-     * 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, requestOptions) {
-        _PageClient_instances.add(this);
-        this.requestOptions = requestOptions;
-        this.siteId = config.siteId || '';
-        this.dotcmsUrl = config.dotcmsUrl;
-    }
-    get(url, options) {
-        if (!options) {
-            return __classPrivateFieldGet(this, _PageClient_instances, "m", _PageClient_getPageFromAPI).call(this, url);
-        }
-        if (__classPrivateFieldGet(this, _PageClient_instances, "m", _PageClient_isGraphQLRequest).call(this, options)) {
-            return __classPrivateFieldGet(this, _PageClient_instances, "m", _PageClient_getPageFromGraphQL).call(this, url, options);
-        }
-        return __classPrivateFieldGet(this, _PageClient_instances, "m", _PageClient_getPageFromAPI).call(this, url, options);
-    }
-}
-_PageClient_instances = new WeakSet(), _PageClient_isGraphQLRequest = function _PageClient_isGraphQLRequest(options) {
-    return 'graphql' in options;
-}, _PageClient_getPageFromAPI = 
-/**
- * Retrieves all the elements of a Page in your dotCMS system in JSON format.
- *
- * @param {string} path - The path of the page to retrieve
- * @param {PageRequestParams} params - The options for the Page API call
- * @returns {Promise<unknown>} A Promise that resolves to the page data
- * @throws {Error} Throws an error if the path parameter is missing or if the fetch request fails
- * @example
- * ```typescript
- * // Get a page with default parameters
- * const homePage = await pageClient.get('/');
- *
- * // Get a page with specific language and mode
- * const aboutPage = await pageClient.get('/about-us', {
- *   languageId: 2,
- *   mode: 'PREVIEW_MODE'
- * });
- *
- * // Get a page with persona targeting
- * const productPage = await pageClient.get('/products', {
- *   personaId: 'persona-123',
- *   depth: 2
- * });
- * ```
- */
-async function _PageClient_getPageFromAPI(path, params) {
-    if (!path) {
-        throw new Error("The 'path' parameter is required for the Page API");
-    }
-    const normalizedParams = __classPrivateFieldGet(this, _PageClient_instances, "m", _PageClient_mapToBackendParams).call(this, params || {});
-    const queryParams = new URLSearchParams(normalizedParams).toString();
-    // If the path starts with a slash, remove it to avoid double slashes in the final URL
-    // Because the page path is part of api url path
-    const pagePath = path.startsWith('/') ? path.slice(1) : path;
-    const url = `${this.dotcmsUrl}/api/v1/page/json/${pagePath}?${queryParams}`;
-    const response = await fetch(url, this.requestOptions);
-    if (!response.ok) {
-        const error = {
-            status: response.status,
-            message: ErrorMessages[response.status] || response.statusText
-        };
-        throw error;
-    }
-    return response.json().then((data) => data.entity);
-}, _PageClient_getPageFromGraphQL = 
-/**
- * Retrieves a personalized page with associated content and navigation.
- *
- * @param {Object} options - Options for the personalized page request
- * @param {string} options.url - The URL of the page to retrieve
- * @param {string} options.languageId - The language ID for the page content
- * @param {string} options.mode - The rendering mode for the page
- * @param {string} options.pageFragment - GraphQL fragment for page data
- * @param {Record<string, string>} options.content - Content queries to include
- * @param {Record<string, string>} options.nav - Navigation queries to include
- * @returns {Promise<Object>} A Promise that resolves to the personalized page data with content and navigation
- * @example
- * ```typescript
- * // Get a personalized page with content and navigation
- * const personalizedPage = await pageClient.getPageFromGraphQL({
- *   url: '/about-us',
- *   languageId: '1',
- *   mode: 'LIVE',
- *   pageFragment: `
- *     fragment PageFields on Page {
- *       title
- *       description
- *       modDate
- *     }
- *   `,
- *   content: {
- *     blogs: `
- *       search(query: "+contentType: blog", limit: 3) {
- *         title
- *         ...on Blog {
- *             author {
- *                 title
- *             }
- *         }
-                            }
- *   nav: {
- *     mainNav: `
- *       query MainNav {
- *         Nav(identifier: "main-nav") {
- *           title
- *           items {
- *             label
- *             url
- *           }
- *         }
- *       }
- *     `
- *   }
- * });
- * ```
- */
-async function _PageClient_getPageFromGraphQL(url, options) {
-    const { languageId = '1', mode = 'LIVE', graphql = {} } = options || {};
-    const { page, content = {}, variables, fragments } = graphql;
-    const contentQuery = buildQuery(content);
-    const completeQuery = buildPageQuery({
-        page,
-        fragments,
-        additionalQueries: contentQuery
-    });
-    const requestVariables = {
-        url,
-        mode,
-        languageId,
-        ...variables
-    };
-    const requestHeaders = this.requestOptions.headers;
-    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) => {
-                throw new Error(error.message);
-            });
-        }
-        const pageResponse = graphqlToPageEntity(data);
-        if (!pageResponse) {
-            throw new Error('No page data found');
-        }
-        const contentResponse = mapResponseData(data, Object.keys(content));
-        return {
-            page: pageResponse,
-            content: contentResponse,
-            errors
-        };
-    }
-    catch (error) {
-        const errorMessage = {
-            error,
-            message: 'Failed to retrieve page data',
-            query: completeQuery,
-            variables: requestVariables
-        };
-        throw errorMessage;
-    }
-}, _PageClient_mapToBackendParams = function _PageClient_mapToBackendParams(params) {
-    const backendParams = {
-        hostId: params.siteId || this.siteId,
-        mode: params.mode,
-        language_id: params.languageId ? String(params.languageId) : undefined,
-        'com.dotmarketing.persona.id': params.personaId,
-        fireRules: params.fireRules ? String(params.fireRules) : undefined,
-        depth: params.depth ? String(params.depth) : undefined,
-        publishDate: params.publishDate
-    };
-    // Remove undefined values
-    return Object.fromEntries(Object.entries(backendParams).filter(([_, value]) => value !== undefined));
-};
-
-/**
- * Parses a string into a URL object.
- *
- * @param url - The URL string to parse
- * @returns A URL object if parsing is successful, undefined otherwise
- */
-function parseURL(url) {
-    try {
-        return new URL(url);
-    }
-    catch {
-        console.error('Invalid URL:', url);
-        return undefined;
-    }
-}
-/**
- * Default configuration for the DotCMS client.
- */
-const defaultConfig = {
-    dotcmsUrl: '',
-    authToken: '',
-    requestOptions: {}
-};
-/**
- * Client for interacting with the DotCMS REST API.
- * Provides access to content, page, and navigation functionality.
- */
-class DotCMSClient {
-    /**
-     * Creates a new DotCMS client instance.
-     *
-     * @param config - Configuration options for the client
-     * @throws Warning if dotcmsUrl is invalid or authToken is missing
-     */
-    constructor(config = defaultConfig) {
-        this.config = config;
-        this.requestOptions = this.createAuthenticatedRequestOptions(this.config);
-        // Initialize clients
-        this.page = new PageClient(this.config, this.requestOptions);
-        this.nav = new NavigationClient(this.config, this.requestOptions);
-        this.content = new Content(this.requestOptions, this.config.dotcmsUrl);
-    }
-    /**
-     * Creates request options with authentication headers.
-     *
-     * @param config - The client configuration
-     * @returns Request options with authorization headers
-     */
-    createAuthenticatedRequestOptions(config) {
-        return {
-            ...config.requestOptions,
-            headers: {
-                ...config.requestOptions?.headers,
-                Authorization: `Bearer ${config.authToken}`
-            }
-        };
-    }
-}
-/**
- * Creates and returns a new DotCMS client instance.
- *
- * @param config - Configuration options for the client
- * @returns A configured DotCMS client instance
- * @example
- * ```typescript
- * const client = dotCMSCreateClient({
- *   dotcmsUrl: 'https://demo.dotcms.com',
- *   authToken: 'your-auth-token'
- * });
- *
- * // Use the client to fetch content
- * const pages = await client.page.get('/about-us');
- * ```
- */
-const createDotCMSClient = (clientConfig) => {
-    const { dotcmsUrl, authToken } = clientConfig || {};
-    const instanceUrl = parseURL(dotcmsUrl)?.origin;
-    if (!instanceUrl) {
-        throw new TypeError("Invalid configuration - 'dotcmsUrl' must be a valid URL");
-    }
-    if (!authToken) {
-        throw new TypeError("Invalid configuration - 'authToken' is required");
-    }
-    const config = {
-        ...clientConfig,
-        authToken,
-        dotcmsUrl: instanceUrl
-    };
-    return new DotCMSClient(config);
-};
-
-export { createDotCMSClient };