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

package/next.esm.js

@@ -0,0 +1,524 @@
+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
+    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: 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 __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 = 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 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 };

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@dotcms/client",
-  "version": "0.0.1-beta.3",
+  "version": "0.0.1-beta.30",
   "description": "Official JavaScript library for interacting with DotCMS REST APIs.",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dotCMS/core.git#main"
   },
+  "devDependencies": {
+    "@dotcms/types": "next"
+  },
   "scripts": {
     "build": "nx run sdk-client:build:js; cd ../../../../dotCMS/src/main/webapp/html/js/editor-js; rm -rf src package.json *.esm.d.ts"
   },
@@ -16,12 +19,6 @@
     "API Client",
     "REST API"
   ],
-  "author": "dotcms <dev@dotcms.com>",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/dotCMS/core/issues"
-  },
-  "homepage": "https://github.com/dotCMS/core/tree/main/core-web/libs/sdk/client/README.md",
   "exports": {
     "./package.json": "./package.json",
     ".": {
@@ -29,8 +26,30 @@
       "types": "./index.esm.d.ts",
       "import": "./index.cjs.mjs",
       "default": "./index.cjs.js"
+    },
+    "./next": {
+      "module": "./next.esm.js",
+      "types": "./next.esm.d.ts",
+      "import": "./next.cjs.mjs",
+      "default": "./next.cjs.js"
     }
   },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./src/index.d.ts"
+      ],
+      "next": [
+        "./src/next.d.ts"
+      ]
+    }
+  },
+  "author": "dotcms <dev@dotcms.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/dotCMS/core/issues"
+  },
+  "homepage": "https://github.com/dotCMS/core/tree/main/core-web/libs/sdk/client/README.md",
   "module": "./index.esm.js",
   "main": "./index.cjs.js",
   "types": "./index.esm.d.ts"

package/src/index.d.ts

@@ -1,8 +1,8 @@
-import { ClientConfig, DotCmsClient } from './lib/client/sdk-js-client';
-import { CLIENT_ACTIONS, postMessageToEditor } from './lib/editor/models/client.model';
-import { CustomClientParams, DotCMSPageEditorConfig, EditorConfig } from './lib/editor/models/editor.model';
-import { InlineEditorData, INLINE_EDITING_EVENT_KEY, InlineEditEventData } from './lib/editor/models/inline-event.model';
-import { NOTIFY_CLIENT } from './lib/editor/models/listeners.model';
-import { destroyEditor, editContentlet, reorderMenu, initEditor, isInsideEditor, updateNavigation, initInlineEditing } from './lib/editor/sdk-editor';
+import { CLIENT_ACTIONS, postMessageToEditor } from './lib/deprecated/editor/models/client.model';
+import { CustomClientParams, DotCMSPageEditorConfig, EditorConfig } from './lib/deprecated/editor/models/editor.model';
+import { InlineEditorData, INLINE_EDITING_EVENT_KEY, InlineEditEventData } from './lib/deprecated/editor/models/inline-event.model';
+import { NOTIFY_CLIENT } from './lib/deprecated/editor/models/listeners.model';
+import { destroyEditor, editContentlet, reorderMenu, initEditor, isInsideEditor, updateNavigation, initInlineEditing } from './lib/deprecated/editor/sdk-editor';
+import { ClientConfig, DotCmsClient } from './lib/deprecated/sdk-js-client';
 import { getPageRequestParams, graphqlToPageEntity } from './lib/utils';
 export { destroyEditor, editContentlet, getPageRequestParams, graphqlToPageEntity, initEditor, initInlineEditing, isInsideEditor, postMessageToEditor, reorderMenu, updateNavigation, DotCmsClient, ClientConfig, CustomClientParams, DotCMSPageEditorConfig, EditorConfig, InlineEditEventData, InlineEditorData, CLIENT_ACTIONS, INLINE_EDITING_EVENT_KEY, NOTIFY_CLIENT };

package/src/lib/client/client.d.ts

@@ -0,0 +1,56 @@
+import { DotCMSClientConfig } from '@dotcms/types';
+import { Content } from './content/content-api';
+import { NavigationClient } from './navigation/navigation-api';
+import { PageClient } from './page/page-api';
+/**
+ * Client for interacting with the DotCMS REST API.
+ * Provides access to content, page, and navigation functionality.
+ */
+declare class DotCMSClient {
+    private config;
+    private requestOptions;
+    /**
+     * Client for content-related operations.
+     */
+    content: Content;
+    /**
+     * Client for page-related operations.
+     */
+    page: PageClient;
+    /**
+     * Client for navigation-related operations.
+     */
+    nav: NavigationClient;
+    /**
+     * 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?: DotCMSClientConfig);
+    /**
+     * Creates request options with authentication headers.
+     *
+     * @param config - The client configuration
+     * @returns Request options with authorization headers
+     */
+    private createAuthenticatedRequestOptions;
+}
+/**
+ * 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');
+ * ```
+ */
+export declare const createDotCMSClient: (clientConfig: DotCMSClientConfig) => DotCMSClient;
+export {};

package/src/lib/client/content/builders/collection/collection.d.ts

@@ -1,4 +1,4 @@
-import { ClientOptions } from '../../../sdk-js-client';
+import { ClientOptions } from '../../../../deprecated/sdk-js-client';
 import { GetCollectionResponse, BuildQuery, SortBy, GetCollectionError, OnFullfilled, OnRejected } from '../../shared/types';
 /**
  * Creates a Builder to filter and fetch content from the content API for a specific content type.

package/src/lib/client/content/content-api.d.ts

@@ -1,5 +1,5 @@
+import { RequestOptions } from '@dotcms/types';
 import { CollectionBuilder } from './builders/collection/collection';
-import { ClientOptions } from '../sdk-js-client';
 /**
  * Creates a builder to filter and fetch a collection of content items.
  * @param contentType - The content type to retrieve.
@@ -56,10 +56,10 @@ export declare class Content {
     #private;
     /**
      * Creates an instance of Content.
-     * @param {ClientOptions} requestOptions - The options for the client request.
+     * @param {RequestOptions} requestOptions - The options for the client request.
      * @param {string} serverUrl - The server URL.
      */
-    constructor(requestOptions: ClientOptions, serverUrl: string);
+    constructor(requestOptions: RequestOptions, serverUrl: string);
     /**
      * Takes a content type and returns a builder to filter and fetch the collection.
      * @param {string} contentType - The content type to get the collection.