@dotcms/client 0.0.1-beta.2 → 0.0.1-beta.21

package/next.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/next";

package/next.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./next.cjs.js').default;

package/next.cjs.js

@@ -0,0 +1,575 @@
+'use strict';
+
+var transforms = require('./transforms.cjs.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
+    urlContentMap {
+      _map
+    }
+    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, $personaId: String, $fireRules: Boolean, $publishDate: String, $siteId: String) {
+    page: page(url: $url, languageId: $languageId, pageMode: $mode, persona: $personaId, fireRules: $fireRules, publishDate: $publishDate, site: $siteId) {
+      ...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: transforms.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 transforms.__classPrivateFieldGet(this, _PageClient_instances, "m", _PageClient_getPageFromAPI).call(this, url);
+        }
+        if (transforms.__classPrivateFieldGet(this, _PageClient_instances, "m", _PageClient_isGraphQLRequest).call(this, options)) {
+            return transforms.__classPrivateFieldGet(this, _PageClient_instances, "m", _PageClient_getPageFromGraphQL).call(this, url, options);
+        }
+        return transforms.__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");
+    }
+    // If the siteId is not provided, use the one from the config
+    const completedParams = {
+        ...(params ?? {}),
+        siteId: params?.siteId || this.siteId
+    };
+    // Map the public parameters to the one used by the API
+    const normalizedParams = transforms.__classPrivateFieldGet(this, _PageClient_instances, "m", _PageClient_mapToBackendParams).call(this, completedParams || {});
+    // Build the query 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: transforms.ErrorMessages[response.status] || response.statusText
+        };
+        throw error;
+    }
+    return response.json().then((data) => ({
+        ...data.entity,
+        params: completedParams // We retrieve the params from the API response, to make the same fetch on UVE
+    }));
+}, _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', siteId = this.siteId, fireRules = false, personaId, publishDate, graphql = {} } = options || {};
+    const { page, content = {}, variables, fragments } = graphql;
+    const contentQuery = buildQuery(content);
+    const completeQuery = buildPageQuery({
+        page,
+        fragments,
+        additionalQueries: contentQuery
+    });
+    const requestVariables = {
+        url,
+        mode,
+        languageId,
+        personaId,
+        fireRules,
+        publishDate,
+        siteId,
+        ...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 = transforms.graphqlToPageEntity(data);
+        if (!pageResponse) {
+            throw new Error('No page data found');
+        }
+        const contentResponse = mapResponseData(data, Object.keys(content));
+        return {
+            page: 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;
+    }
+}, _PageClient_mapToBackendParams = function _PageClient_mapToBackendParams(params) {
+    const backendParams = {
+        hostId: params.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 transforms.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);
+};
+
+exports.createDotCMSClient = createDotCMSClient;

package/next.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './next.cjs.js';
+export { _default as default } from './next.cjs.default.js';

package/next.esm.d.ts

@@ -0,0 +1 @@
+export * from "./src/next";