@dotcms/client 0.0.1-alpha.37 → 0.0.1-alpha.39

package/src/lib/utils/graphql/transforms.ts

@@ -0,0 +1,99 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Represents the response from a GraphQL query for a page.
+ *
+ * @interface GraphQLPageResponse
+ * @property {Record<string, unknown>} page - The main page data.
+ * @property {unknown} [key: string] - Additional properties that may be included in the response.
+ */
+interface GraphQLPageResponse {
+    page: Record<string, unknown>;
+    [key: string]: unknown;
+}
+
+/**
+ * Transforms a GraphQL Page response to a Page Entity.
+ *
+ * @param {GraphQLPageResponse} graphQLPageResponse - The GraphQL Page response object.
+ * @returns {object|null} The transformed Page Entity or null if the page is not present.
+ *
+ * @example
+ * ```ts
+ * const pageEntity = graphqlToPageEntity(graphQLPageResponse);
+ * ```
+ */
+export const graphqlToPageEntity = (graphQLPageResponse: GraphQLPageResponse) => {
+    const { page } = graphQLPageResponse;
+
+    // If there is no page, return null
+    if (!page) {
+        return null;
+    }
+
+    const { layout, template, containers, urlContentMap, viewAs, site, _map, ...pageAsset } = page;
+    const data = (_map || {}) as Record<string, unknown>;
+
+    return {
+        layout,
+        template,
+        viewAs,
+        urlContentMap,
+        site,
+        page: {
+            ...data,
+            ...pageAsset
+        },
+        containers: parseContainers(containers as [])
+    } as any;
+};
+
+/**
+ * Parses the containers from the GraphQL response.
+ *
+ * @param {Array<Record<string, unknown>>} [containers=[]] - The containers array from the GraphQL response.
+ * @returns {Record<string, unknown>} The parsed containers.
+ */
+const parseContainers = (containers: Record<string, unknown>[] = []) => {
+    return containers.reduce((acc: Record<string, unknown>, container: Record<string, unknown>) => {
+        const { path, identifier, containerStructures, containerContentlets, ...rest } = container;
+
+        const key = (path || identifier) as string;
+
+        acc[key] = {
+            containerStructures,
+            container: {
+                path,
+                identifier,
+                ...rest
+            },
+            contentlets: parseContentletsToUuidMap(containerContentlets as [])
+        };
+
+        return acc;
+    }, {});
+};
+
+/**
+ * Parses the contentlets from the GraphQL response.
+ *
+ * @param {Array<Record<string, unknown>>} containerContentlets - The contentlets array from the GraphQL response.
+ * @returns {Record<string, Array<Record<string, unknown>>>} The parsed contentlets mapped by UUID.
+ */
+const parseContentletsToUuidMap = (containerContentlets: Record<string, unknown>[] = []) => {
+    return containerContentlets.reduce((acc, containerContentlet) => {
+        const { uuid, contentlets } = containerContentlet as {
+            uuid: string;
+            contentlets: Record<string, unknown>[];
+        };
+
+        // TODO: This is a temporary solution, we need to find a better way to handle this.
+        acc[uuid] = contentlets.map(({ _map = {}, ...rest }) => {
+            return {
+                ...(_map as Record<string, unknown>),
+                ...rest
+            };
+        });
+
+        return acc;
+    }, {});
+};

package/src/lib/utils/page/common-utils.spec.ts

@@ -0,0 +1,37 @@
+import { getPageRequestParams } from './common-utils';
+
+describe('Common Utils', () => {
+    it('should return the correct Request Params', () => {
+        const pageRequestParams = getPageRequestParams({
+            path: 'test',
+            params: {
+                personaId: '123',
+                language_id: '1',
+                mode: 'LIVE',
+                variantName: 'default'
+            }
+        });
+
+        expect(pageRequestParams).toEqual({
+            path: 'test',
+            mode: 'LIVE',
+            language_id: '1',
+            variantName: 'default',
+            personaId: '123'
+        });
+    });
+
+    it('should return the correct Request Params with empty params', () => {
+        const pageRequestParams = getPageRequestParams({
+            path: 'test',
+            params: {
+                personaId: '',
+                language_id: '',
+                mode: '',
+                variantName: ''
+            }
+        });
+
+        expect(pageRequestParams).toEqual({ path: 'test' });
+    });
+});

package/src/lib/utils/page/common-utils.ts

@@ -0,0 +1,64 @@
+import { PageApiOptions } from '../../client/sdk-js-client';
+
+/**
+ * Interface representing the properties for page request parameters.
+ *
+ * @export
+ * @interface PageRequestParamsProps
+ */
+export interface PageRequestParamsProps {
+    /**
+     * The API endpoint path.
+     * @type {string}
+     */
+    path: string;
+
+    /**
+     * The query parameters for the API request.
+     * Can be an object with key-value pairs or a URLSearchParams instance.
+     * @type {{ [key: string]: unknown } | URLSearchParams}
+     */
+    params: { [key: string]: unknown } | URLSearchParams;
+}
+
+/**
+ * Generates the page request parameters to be used in the API call.
+ *
+ * @param {PageRequestParamsProps} PageRequestParamsProps - The properties for the page request.
+ * @returns {PageApiOptions} The options for the page API.
+ * @example
+ * ```ts
+ * const pageApiOptions = getPageRequestParams({ path: '/api/v1/page', params: queryParams });
+ * ```
+ */
+export const getPageRequestParams = ({
+    path = '',
+    params = {}
+}: PageRequestParamsProps): PageApiOptions => {
+    const copiedParams: PageRequestParamsProps['params'] =
+        params instanceof URLSearchParams ? Object.fromEntries(params.entries()) : { ...params };
+
+    const finalParams: Record<string, unknown> = {};
+    const dotMarketingPersonaId = copiedParams['com.dotmarketing.persona.id'] || '';
+
+    if (copiedParams['mode']) {
+        finalParams['mode'] = copiedParams['mode'];
+    }
+
+    if (copiedParams['language_id']) {
+        finalParams['language_id'] = copiedParams['language_id'];
+    }
+
+    if (copiedParams['variantName']) {
+        finalParams['variantName'] = copiedParams['variantName'];
+    }
+
+    if (copiedParams['personaId'] || dotMarketingPersonaId) {
+        finalParams['personaId'] = copiedParams['personaId'] || dotMarketingPersonaId;
+    }
+
+    return {
+        path,
+        ...finalParams
+    };
+};

package/tsconfig.json

@@ -0,0 +1,22 @@
+{
+    "extends": "../../../tsconfig.base.json",
+    "compilerOptions": {
+        "module": "ESNext",
+        "forceConsistentCasingInFileNames": true,
+        "strict": true,
+        "noImplicitOverride": true,
+        "noPropertyAccessFromIndexSignature": true,
+        "noImplicitReturns": true,
+        "noFallthroughCasesInSwitch": true
+    },
+    "files": [],
+    "include": [],
+    "references": [
+        {
+            "path": "./tsconfig.lib.json"
+        },
+        {
+            "path": "./tsconfig.spec.json"
+        }
+    ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,13 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "outDir": "../../../dist/out-tsc",
+        "declaration": true,
+        "types": [""],
+        "target": "es2020",
+        "module": "es2020",
+        "moduleResolution": "node"
+    },
+    "include": ["src/**/*.ts"],
+    "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,9 @@
+{
+    "extends": "./tsconfig.json",
+    "compilerOptions": {
+        "outDir": "../../../dist/out-tsc",
+        "module": "commonjs",
+        "types": ["jest", "node"]
+    },
+    "include": ["jest.config.ts", "src/**/*.test.ts", "src/**/*.spec.ts", "src/**/*.d.ts"]
+}

package/index.cjs.d.ts

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

package/index.cjs.default.js

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