✨ Introduce Hydrater

Author: Plopix

package.json

@@ -26,5 +26,5 @@
     },
     "license": "MIT",
     "name": "@crystallize/js-api-client",
-    "version": "0.3.0"
+    "version": "0.3.1"
 }

src/core/hydrate.ts

@@ -0,0 +1,150 @@
+import { jsonToGraphQLQuery } from 'json-to-graphql-query';
+import { ClientInterface } from './client';
+
+export type ProductHydrater = (
+    items: string[],
+    language: string,
+    extraQuery?: any,
+    perProduct?: (item: string, index: number) => any
+) => Promise<any>;
+
+export function createProductHydraterByPaths(
+    client: ClientInterface
+): ProductHydrater {
+    return <T>(
+        paths: string[],
+        language: string,
+        extraQuery?: any,
+        perProduct?: (item: string, index: number) => any
+    ): Promise<T> => {
+        const productListQuery = paths
+            .map((path: string, index: number) => {
+                return {
+                    [`product${index}`]: {
+                        __aliasFor: 'catalogue',
+                        __args: { path, language },
+                        name: true,
+                        path: true,
+                        __on: {
+                            __typeName: 'Product',
+                            id: true,
+                            vatType: {
+                                name: true,
+                                percent: true
+                            },
+                            variants: {
+                                id: true,
+                                sku: true,
+                                name: true,
+                                stock: true,
+                                priceVariants: {
+                                    price: true,
+                                    identifier: true,
+                                    currency: true
+                                }
+                            },
+                            ...(perProduct !== undefined
+                                ? perProduct(path, index)
+                                : {})
+                        }
+                    }
+                };
+            })
+            .reduce((acc, curr) => {
+                return { ...acc, ...curr };
+            }, {});
+
+        const query = {
+            query: {
+                ...{ ...productListQuery },
+                ...(extraQuery !== undefined ? extraQuery : {})
+            }
+        };
+
+        const fetch = client.catalogueApi;
+        return fetch(jsonToGraphQLQuery(query));
+    };
+}
+
+export function createProductHydraterBySkus(
+    client: ClientInterface
+): ProductHydrater {
+    async function getPathForSkus(
+        skus: string[],
+        language: string
+    ): Promise<string[]> {
+        const search = client.searchApi;
+        const pathsSet = new Set<string>();
+        let searchAfterCursor: any;
+        async function getNextSearchPage() {
+            const searchAPIResponse = await search(
+                `query GET_PRODUCTS_BY_SKU ($skus: [String!], $after: String, $language: String!) {
+            search (
+                after: $after
+                language: $language
+                filter: {
+                    include: {
+                        skus: $skus
+                    }
+                }
+            ) {
+                pageInfo {
+                    endCursor
+                    hasNextPage
+                }
+                edges {
+                    node {
+                        path
+                    }
+                }
+            }
+        }`,
+                {
+                    skus: skus,
+                    after: searchAfterCursor,
+                    language
+                }
+            );
+
+            const { edges, pageInfo } = searchAPIResponse.search || {};
+
+            edges?.forEach((edge: any) => pathsSet.add(edge.node.path));
+
+            if (pageInfo?.hasNextPage) {
+                searchAfterCursor = pageInfo.endCursor;
+                await getNextSearchPage();
+            }
+        }
+
+        await getNextSearchPage();
+
+        return Array.from(pathsSet);
+    }
+    return async <T>(
+        skus: string[],
+        language: string,
+        extraQuery?: any,
+        perProduct?: (item: string, index: number) => any
+    ): Promise<T> => {
+        const paths = await getPathForSkus(skus, language);
+        if (paths.length === 0) {
+            const empty = skus
+                .map((sku: string, index: number) => {
+                    return {
+                        [`product${index}`]: {}
+                    };
+                })
+                .reduce((acc, curr) => {
+                    return { ...acc, ...curr };
+                });
+
+            return empty as any;
+        }
+        return createProductHydraterByPaths(client)(
+            paths,
+            language,
+            extraQuery,
+            perProduct
+        );
+    };
+}

src/index.ts

@@ -1,7 +1,15 @@
 export * from './core/client';
 export * from './core/navigation';
+export * from './core/hydrate';
 import { createClient } from './core/client';
-import { createNavigationByFoldersFetcher } from './core/navigation';
+import {
+    createNavigationByFoldersFetcher,
+    createNavigationByTopicsFetcher
+} from './core/navigation';
+import {
+    createProductHydraterByPaths,
+    createProductHydraterBySkus
+} from './core/hydrate';
 
 export const CrystallizeClient = createClient({
     tenantIdentifier: process.env.CRYSTALLIZE_TENANT_IDENTIFIER || '',
@@ -11,3 +19,9 @@ export const CrystallizeClient = createClient({
 
 export const CrystallizeNavigationTreeFetcher =
     createNavigationByFoldersFetcher(CrystallizeClient);
+export const CrystallizeNavigationTopicsFetcher =
+    createNavigationByTopicsFetcher(CrystallizeClient);
+export const CrystallizeHydraterByPaths =
+    createProductHydraterByPaths(CrystallizeClient);
+export const CrystallizeHydraterBySkus =
+    createProductHydraterBySkus(CrystallizeClient);

tests/call.test.js

@@ -41,3 +41,41 @@ test('callCatalogueApi: Raw fetch Error', async () => {
     });
     expect(response.length).toBeGreaterThanOrEqual(1);
 });
+
+test('callSearchApi: Raw fetch Skus', async () => {
+    const CrystallizeClient = createClient({
+        tenantIdentifier: 'furniture'
+    });
+
+    const caller = CrystallizeClient.searchApi;
+
+    const query = `query GET_PRODUCTS_BY_SKU ($skus: [String!], $after: String, $language: String!) {
+            search (
+              after: $after
+              language: $language
+              filter: {
+                include: {
+                  skus: $skus
+                }
+              }
+            ) {
+              pageInfo {
+                endCursor
+                hasNextPage
+              }
+              edges {
+                node {
+                  path
+                }
+              }
+            }
+          }`;
+    const response = await caller(query, {
+        skus: ['b-1628520141076'],
+        language: 'en'
+    });
+
+    expect(response.search.edges[0].node.path).toBe(
+        '/shop/bathroom-fitting/large-mounted-cabinet-in-treated-wood'
+    );
+});

tests/hydrate.paths.test.js

@@ -0,0 +1,26 @@
+const {
+    createClient,
+    createProductHydraterByPaths
+} = require('../dist/index.js');
+
+test('Hydrate Paths', async () => {
+    const CrystallizeClient = createClient({
+        tenantIdentifier: 'furniture'
+    });
+
+    const hydrater = createProductHydraterByPaths(CrystallizeClient);
+    const response = await hydrater(
+        [
+            '/shop/bathroom-fitting/large-mounted-cabinet-in-treated-wood',
+            '/shop/bathroom-fitting/mounted-bathroom-counter-with-shelf'
+        ],
+        'en'
+    );
+
+    expect(response.product0.path).toBe(
+        '/shop/bathroom-fitting/large-mounted-cabinet-in-treated-wood'
+    );
+    expect(response.product1.path).toBe(
+        '/shop/bathroom-fitting/mounted-bathroom-counter-with-shelf'
+    );
+});

tests/hydrate.skus.test.js

@@ -0,0 +1,23 @@
+const {
+    createClient,
+    createProductHydraterBySkus
+} = require('../dist/index.js');
+
+test('Hydrate Skus', async () => {
+    const CrystallizeClient = createClient({
+        tenantIdentifier: 'furniture'
+    });
+
+    const hydrater = createProductHydraterBySkus(CrystallizeClient);
+    const response = await hydrater(
+        ['b-1628520141076', 'b-1628514494819'],
+        'en'
+    );
+
+    expect(response.product0.path).toBe(
+        '/shop/bathroom-fitting/large-mounted-cabinet-in-treated-wood'
+    );
+    expect(response.product1.path).toBe(
+        '/shop/bathroom-fitting/mounted-bathroom-counter-with-shelf'
+    );
+});