@dotcms/client 0.0.1-beta.3 → 0.0.1-beta.30

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,526 @@
+'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
+    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
+    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 {
+          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) {
+    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_getPageFromGraphQL;
+/**
+ * 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;
+    }
+    /**
+     * 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
+     *                      }
+     *                  `
+     *              ]
+     *          }
+     *      });
+     * ```
+     */
+    get(url, options) {
+        return transforms.__classPrivateFieldGet(this, _PageClient_instances, "m", _PageClient_getPageFromGraphQL).call(this, url, options);
+    }
+}
+_PageClient_instances = new WeakSet(), _PageClient_getPageFromGraphQL = 
+/**
+ * Private implementation method that fetches page data using GraphQL.
+ * This method is used internally by the public get() method.
+ *
+ * @private
+ * @param {string} url - The URL of the page to retrieve
+ * @param {DotCMSPageRequestParams} [options] - Options including languageId, mode, and GraphQL parameters
+ * @returns {Promise<DotCMSComposedPageResponse<T>>} A Promise that resolves to the page data
+ */
+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 {
+            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;
+    }
+};
+
+/**
+ * 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";