@gem-sdk/core 2.0.0-dev.896 → 2.0.0

package/dist/cjs/helpers/queries/get-collection.js

@@ -1 +1,226 @@
-"use strict";var collectionDetailFilter_generated=require("../../graphql/queries/collection-detail-filter.generated.js"),productVariants_generated=require("../../graphql/queries/product-variants.generated.js"),isDefined=require("../is-defined.js");const PRODUCT_PER_PAGE=8;function productSortedByOrder(e){switch(e){case"TITLE_ASC":case"none":default:return{direction:"ASC",field:"TITLE"};case"TITLE_DESC":return{direction:"DESC",field:"TITLE"};case"CREATED_AT_ASC":return{direction:"ASC",field:"PLATFORM_CREATED_AT"};case"CREATED_AT_DESC":return{direction:"DESC",field:"PLATFORM_CREATED_AT"}}}const getCollection=async(e,t)=>{let r=await loopFetchCollection(e,t);if(!r)throw Error("collections not found");let o=await mergeProductCollectionVariant(e,r,t.isSample);return o},fetchCollection=async(e,t)=>e([collectionDetailFilter_generated.CollectionDetailFilterDocument,t]),calculateFirstProduct=(e,t,r)=>{let o=e-r*t;return e<r?e:o>0?r:r+o},chunkArray=(e,t)=>{let r=[],o=0;for(;o<e.length;)r.push(e.slice(o,t+o)),o+=t;return r},loopFetchCollection=async(e,t)=>{let r,o,i,n,d;let s=1;if(t.numberOfProducts){let a=Math.ceil(t.numberOfProducts/8);for(;s<=a&&!1!==n;){r={firstVariant:1,firstMedia:30,orderBy:{field:"PLATFORM_UPDATED_AT",direction:"DESC"},orderByMedia:{field:"POSITION",direction:"ASC"},firstProduct:calculateFirstProduct(t.numberOfProducts,s,8),...t.id&&"latest"!==t.id.toLowerCase()?{where:{baseID:t.id}}:{where:{isSample:t.isSample}},orderByProduct:productSortedByOrder(t.orderBy),whereProduct:{status:"ACTIVE",...t.isStorefront&&{isStorefront:t.isStorefront},isSample:t.isSample},...o?{productsAfter:o}:void 0};let a=await fetchCollection(e,r);if(o=a?.collections?.edges?.[0]?.node?.products?.pageInfo?.endCursor,1===s?(i=a,d=i?.collections?.edges?.[0]):d?.node?.products&&a?.collections?.edges?.[0]?.node?.products?.edges&&(d.node.products={pageInfo:a?.collections?.edges?.[0]?.node?.products?.pageInfo,edges:d.node?.products?.edges.concat(a?.collections?.edges?.[0]?.node?.products?.edges)}),s++,!d?.node?.products?.pageInfo?.hasNextPage){n=!1;break}}return i}},mergeProductCollectionVariant=async(e,t,r)=>{let o=t?.collections?.edges?.[0]?.node;if(!o)return t;let i=o?.products?.edges,n=i?.map(e=>e?.node?.baseID).filter(isDefined.isDefined),d=await fetchVariantsByBaseIds(e,{ids:n,isSample:r}),s=i?.map(e=>{let t=d?.variants?.edges?.filter(t=>t?.node?.id===e?.node?.id);return{...e,node:e.node?{...e.node,variants:e.node?.variants?{...e.node?.variants,edges:t?.[0]?.node?.variants?.edges??[]}:void 0}:void 0}})??[],a={...t,collections:{edges:[{node:{...o,products:{edges:s}},cursor:void 0}]}};return a},fetchVariantsByBaseIds=async(e,{ids:t,isSample:r,isStorefront:o})=>{let i=chunkArray(t??[],8),n=[],d=async t=>{try{return await e([productVariants_generated.ProductVariantsDocument,{...t,orderByVariant:{field:"POSITION",direction:"ASC"}}])}catch{return{}}},s=i.map(e=>{let t={firstVariant:100,first:e.length,orderBy:{field:"TITLE",direction:"ASC"},where:{status:"ACTIVE",isSample:r,...o&&{isStorefront:o},...e.length&&{baseIDIn:e.sort()}}};return d(t)}),a=await Promise.all(s),c=a?.reduce((e,t)=>e.concat(t?.variants?.edges??[]),n);return{variants:{edges:c}}};exports.calculateFirstProduct=calculateFirstProduct,exports.getCollection=getCollection;
+'use strict';
+
+var collectionDetailFilter_generated = require('../../graphql/queries/collection-detail-filter.generated.js');
+var productVariants_generated = require('../../graphql/queries/product-variants.generated.js');
+var isDefined = require('../is-defined.js');
+
+const PRODUCT_PER_PAGE = 8; // number of products per page
+function productSortedByOrder(key) {
+    switch(key){
+        case 'TITLE_ASC':
+            return {
+                direction: 'ASC',
+                field: 'TITLE'
+            };
+        case 'TITLE_DESC':
+            return {
+                direction: 'DESC',
+                field: 'TITLE'
+            };
+        case 'CREATED_AT_ASC':
+            return {
+                direction: 'ASC',
+                field: 'CREATED_AT'
+            };
+        case 'CREATED_AT_DESC':
+            return {
+                direction: 'DESC',
+                field: 'CREATED_AT'
+            };
+        case 'none':
+        default:
+            return {
+                direction: 'ASC',
+                field: 'TITLE'
+            };
+    }
+}
+const getCollection = async (fetcher, arg)=>{
+    const collections = await loopFetchCollection(fetcher, arg);
+    if (!collections) {
+        throw new Error('collections not found');
+    }
+    // merge product collection variant
+    const mergeProducts = await mergeProductCollectionVariant(fetcher, collections, arg.isSample);
+    return mergeProducts;
+};
+const fetchCollection = async (fetcher, variables)=>{
+    return fetcher([
+        collectionDetailFilter_generated.CollectionDetailFilterDocument,
+        variables
+    ]);
+};
+const calculateFirstProduct = (numberOfProducts, currentPage, productsPerPage)=>{
+    const remainingProducts = numberOfProducts - productsPerPage * currentPage;
+    if (numberOfProducts < productsPerPage) return numberOfProducts;
+    return remainingProducts > 0 ? productsPerPage : productsPerPage + remainingProducts;
+};
+const chunkArray = (array, size)=>{
+    const chunked_arr = [];
+    let index = 0;
+    while(index < array.length){
+        chunked_arr.push(array.slice(index, size + index));
+        index += size;
+    }
+    return chunked_arr;
+};
+const loopFetchCollection = async (fetcher, arg)=>{
+    let variables; // variables of collection query
+    let productAfterFetcher; // product after of collection query
+    let dataCollection; // data of collection query
+    let hasNextPage; //
+    let firstCollection;
+    let currentPage = 1;
+    if (arg.numberOfProducts) {
+        const pages = Math.ceil(arg.numberOfProducts / PRODUCT_PER_PAGE);
+        while(currentPage <= pages && hasNextPage !== false){
+            variables = {
+                firstVariant: 1,
+                firstMedia: 30,
+                orderBy: {
+                    field: 'PLATFORM_CREATED_AT',
+                    direction: 'DESC'
+                },
+                orderByMedia: {
+                    field: 'POSITION',
+                    direction: 'ASC'
+                },
+                firstProduct: calculateFirstProduct(arg.numberOfProducts, currentPage, PRODUCT_PER_PAGE),
+                ...!arg.id || arg.id.toLowerCase() === 'latest' ? {
+                    where: {
+                        hasCollectionProducts: true,
+                        isSample: arg.isSample
+                    }
+                } : {
+                    where: {
+                        baseID: arg.id
+                    }
+                },
+                orderByProduct: productSortedByOrder(arg.orderBy),
+                whereProduct: {
+                    status: 'ACTIVE',
+                    ...arg.isStorefront && {
+                        isStorefront: arg.isStorefront
+                    },
+                    isSample: arg.isSample
+                },
+                ...productAfterFetcher ? {
+                    productsAfter: productAfterFetcher
+                } : undefined
+            };
+            const pageData = await fetchCollection(fetcher, variables);
+            productAfterFetcher = pageData?.collections?.edges?.[0]?.node?.products?.pageInfo?.endCursor;
+            if (currentPage === 1) {
+                dataCollection = pageData; // set data of first page
+                firstCollection = dataCollection?.collections?.edges?.[0];
+            } else if (firstCollection?.node?.products && pageData?.collections?.edges?.[0]?.node?.products?.edges) {
+                // concat new values to the old ones
+                firstCollection.node.products = {
+                    pageInfo: pageData?.collections?.edges?.[0]?.node?.products?.pageInfo,
+                    edges: firstCollection.node?.products?.edges.concat(pageData?.collections?.edges?.[0]?.node?.products?.edges)
+                };
+            }
+            currentPage++;
+            // hasNextPage = false if there is no more pages then break the loop
+            if (!firstCollection?.node?.products?.pageInfo?.hasNextPage) {
+                hasNextPage = false;
+                break;
+            }
+        }
+        return dataCollection;
+    }
+};
+const mergeProductCollectionVariant = async (fetcher, collection, isSample)=>{
+    const node = collection?.collections?.edges?.[0]?.node;
+    if (!node) return collection;
+    const productList = node?.products?.edges;
+    const listBaseId = productList?.map((product)=>product?.node?.baseID).filter(isDefined.isDefined);
+    const ProductListWithVariants = await fetchVariantsByBaseIds(fetcher, {
+        ids: listBaseId,
+        isSample
+    });
+    // mapping variant to product list in collections
+    const newProductList = productList?.map((product)=>{
+        const productVariants = ProductListWithVariants?.variants?.edges?.filter((productV)=>productV?.node?.id === product?.node?.id);
+        return {
+            ...product,
+            node: product.node ? {
+                ...product.node,
+                variants: product.node?.variants ? {
+                    ...product.node?.variants,
+                    edges: productVariants?.[0]?.node?.variants?.edges ?? product.node?.variants.edges ?? []
+                } : undefined
+            } : undefined
+        };
+    }) ?? [];
+    const newCollection = {
+        ...collection,
+        collections: {
+            edges: [
+                {
+                    node: {
+                        ...node,
+                        products: {
+                            edges: newProductList
+                        }
+                    },
+                    cursor: undefined
+                }
+            ]
+        }
+    };
+    return newCollection;
+};
+const fetchVariantsByBaseIds = async (fetcher, { ids, isSample, isStorefront })=>{
+    const chunkedIds = chunkArray(ids ?? [], 8);
+    const defaultEdges = [];
+    const query = async (variables)=>{
+        try {
+            return await fetcher([
+                productVariants_generated.ProductVariantsDocument,
+                {
+                    ...variables,
+                    orderByVariant: {
+                        field: 'POSITION',
+                        direction: 'ASC'
+                    }
+                }
+            ]);
+        } catch  {
+            return {};
+        }
+    };
+    const promises = chunkedIds.map((chunkedId)=>{
+        const variables = {
+            firstVariant: 100,
+            first: chunkedId.length,
+            orderBy: {
+                field: 'TITLE',
+                direction: 'ASC'
+            },
+            where: {
+                status: 'ACTIVE',
+                isSample,
+                ...isStorefront && {
+                    isStorefront
+                },
+                ...chunkedId.length && {
+                    baseIDIn: chunkedId.sort()
+                }
+            }
+        };
+        return query(variables);
+    });
+    const responses = await Promise.all(promises);
+    const edges = responses?.reduce((acc, response)=>{
+        return acc.concat(response?.variants?.edges ?? []);
+    }, defaultEdges);
+    return {
+        variants: {
+            edges
+        }
+    };
+};
+
+exports.calculateFirstProduct = calculateFirstProduct;
+exports.getCollection = getCollection;

package/dist/cjs/helpers/queries/get-collections.js

@@ -1 +1,21 @@
-"use strict";var collections_generated=require("../../graphql/queries/collections.generated.js");const getCollections=async(e,t)=>{let o=await fetchCollections(e,t??{});if(!o)throw Error("Collection not found");return{...o}},fetchCollections=async(e,t)=>e([collections_generated.CollectionsDocument,t]);exports.getCollections=getCollections;
+'use strict';
+
+var collections_generated = require('../../graphql/queries/collections.generated.js');
+
+const getCollections = async (fetcher, variable)=>{
+    const collections = await fetchCollections(fetcher, variable ?? {});
+    if (!collections) {
+        throw new Error('Collection not found');
+    }
+    return {
+        ...collections
+    };
+};
+const fetchCollections = async (fetcher, variables)=>{
+    return fetcher([
+        collections_generated.CollectionsDocument,
+        variables
+    ]);
+};
+
+exports.getCollections = getCollections;

package/dist/cjs/helpers/queries/get-product-by-slug.js

@@ -1 +1,125 @@
-"use strict";var productLittleDetail_generated=require("../../graphql/queries/product-little-detail.generated.js"),productMedias_generated=require("../../graphql/queries/product-medias.generated.js"),productVariants_generated=require("../../graphql/queries/product-variants.generated.js");const getProductBySlug=async(e,t)=>{let[r,a,d]=await Promise.all([fetchProduct(e,t),fetchVariants(e,t),fetchMedias(e,t)]);if(!r)throw Error("Product not found");return{...r,variants:{edges:a},medias:{edges:d}}},orderBy={field:"PLATFORM_UPDATED_AT",direction:"DESC"},fetchProduct=async(e,t,r)=>{let a={orderBy,where:{status:"ACTIVE",handle:t,...r&&{isStorefront:r}}},d=await e([productLittleDetail_generated.ProductLittleDetailDocument,a]);return d.product?.edges?.[0]?.node},fetchVariants=async(e,t,r)=>{let a={orderBy,orderByVariant:{field:"POSITION",direction:"ASC"},where:{status:"ACTIVE",handle:t,...r&&{isStorefront:r}}},d=async(t,r)=>{try{let a=await e([productVariants_generated.ProductVariantsDocument,t]),n=a.variants?.edges?.[0],i=r?.concat(n?.node?.variants?.edges??[]);if(n?.node?.variants?.pageInfo?.hasNextPage)return d({...t,afterVariant:n?.node?.variants?.pageInfo.endCursor},i);return i??[]}catch{return r??[]}};return d(a,[])},fetchMedias=async(e,t,r)=>{let a={orderBy,where:{status:"ACTIVE",handle:t,...r&&{isStorefront:r}},orderByMedia:{field:"POSITION",direction:"ASC"}},d=async t=>{try{let r=await e([productMedias_generated.ProductMediasDocument,t]),a=r.medias?.edges?.[0],n=a?.node?.medias?.edges??[];if(a?.node?.medias?.pageInfo?.hasNextPage)try{let e=await d({...t,afterMedia:a?.node?.medias?.pageInfo.endCursor});return n.concat(e)}catch{}return n}catch{return[]}};return d(a)};exports.getProductBySlug=getProductBySlug;
+'use strict';
+
+var productLittleDetail_generated = require('../../graphql/queries/product-little-detail.generated.js');
+var productMedias_generated = require('../../graphql/queries/product-medias.generated.js');
+var productVariants_generated = require('../../graphql/queries/product-variants.generated.js');
+
+const getProductBySlug = async (fetcher, slug)=>{
+    const [product, variants, medias] = await Promise.all([
+        fetchProduct(fetcher, slug),
+        fetchVariants(fetcher, slug),
+        fetchMedias(fetcher, slug)
+    ]);
+    if (!product) {
+        throw new Error('Product not found');
+    }
+    return {
+        ...product,
+        variants: {
+            edges: variants
+        },
+        medias: {
+            edges: medias
+        }
+    };
+};
+const orderBy = {
+    field: 'PLATFORM_UPDATED_AT',
+    direction: 'DESC'
+};
+const fetchProduct = async (fetcher, handle, isStorefront)=>{
+    const variables = {
+        orderBy,
+        where: {
+            status: 'ACTIVE',
+            handle,
+            ...isStorefront && {
+                isStorefront
+            }
+        }
+    };
+    const response = await fetcher([
+        productLittleDetail_generated.ProductLittleDetailDocument,
+        variables
+    ]);
+    return response.product?.edges?.[0]?.node;
+};
+const fetchVariants = async (fetcher, handle, isStorefront)=>{
+    const initVariables = {
+        orderBy,
+        orderByVariant: {
+            field: 'POSITION',
+            direction: 'ASC'
+        },
+        where: {
+            status: 'ACTIVE',
+            handle,
+            ...isStorefront && {
+                isStorefront
+            }
+        }
+    };
+    const query = async (variables, olds)=>{
+        try {
+            const response = await fetcher([
+                productVariants_generated.ProductVariantsDocument,
+                variables
+            ]);
+            const product = response.variants?.edges?.[0];
+            const items = olds?.concat(product?.node?.variants?.edges ?? []);
+            if (product?.node?.variants?.pageInfo?.hasNextPage) {
+                return query({
+                    ...variables,
+                    afterVariant: product?.node?.variants?.pageInfo.endCursor
+                }, items);
+            }
+            return items ?? [];
+        } catch  {
+            return olds ?? [];
+        }
+    };
+    return query(initVariables, []);
+};
+const fetchMedias = async (fetcher, handle, isStorefront)=>{
+    const initVariables = {
+        orderBy,
+        where: {
+            status: 'ACTIVE',
+            handle,
+            ...isStorefront && {
+                isStorefront
+            }
+        },
+        orderByMedia: {
+            field: 'POSITION',
+            direction: 'ASC'
+        }
+    };
+    const query = async (variables)=>{
+        try {
+            const response = await fetcher([
+                productMedias_generated.ProductMediasDocument,
+                variables
+            ]);
+            const product = response.medias?.edges?.[0];
+            const items = product?.node?.medias?.edges ?? [];
+            if (product?.node?.medias?.pageInfo?.hasNextPage) {
+                try {
+                    const newData = await query({
+                        ...variables,
+                        afterMedia: product?.node?.medias?.pageInfo.endCursor
+                    });
+                    return items.concat(newData);
+                } catch  {
+                    return items;
+                }
+            }
+            return items;
+        } catch  {
+            return [];
+        }
+    };
+    return query(initVariables);
+};
+
+exports.getProductBySlug = getProductBySlug;

package/dist/cjs/helpers/queries/get-product.js

@@ -1 +1,154 @@
-"use strict";var productLittleDetail_generated=require("../../graphql/queries/product-little-detail.generated.js"),productMedias_generated=require("../../graphql/queries/product-medias.generated.js"),productVariants_generated=require("../../graphql/queries/product-variants.generated.js");const getProduct=async(e,{id:t,isSample:r,isStorefront:a})=>{let[s,d,o]=await Promise.all([fetchProduct(e,{id:t,isSample:r,isStorefront:a}),fetchVariants(e,{id:t,isSample:r,isStorefront:a}),fetchMedias(e,{id:t,isSample:r,isStorefront:a})]);if(!s)throw Error("Product not found");return{...s,variants:{edges:d},medias:{edges:o}}},orderBy={field:"PLATFORM_CREATED_AT",direction:"DESC"},fetchProduct=async(e,{id:t,isSample:r,isStorefront:a})=>{let s={orderBy,where:{isSample:r,...a&&{isStorefront:a},...(!t||t&&"latest"==t.toLowerCase())&&{status:"ACTIVE"},...t&&"latest"!==t.toLowerCase()&&{baseID:t}}},d=await e([productLittleDetail_generated.ProductLittleDetailDocument,s]);return d.product?.edges?.[0]?.node},fetchVariants=async(e,{id:t,isSample:r,isStorefront:a})=>{let s={orderBy,where:{isSample:r,...a&&{isStorefront:a},...(!t||t&&"latest"==t.toLowerCase())&&{status:"ACTIVE"},...t&&"latest"!==t.toLowerCase()&&{baseID:t}},orderByVariant:{field:"POSITION",direction:"ASC"}},d=async(t,r)=>{try{let a=await e([productVariants_generated.ProductVariantsDocument,t]),s=a.variants?.edges?.[0],o=r?.concat(s?.node?.variants?.edges??[]);if(s?.node?.variants?.pageInfo?.hasNextPage)return d({...t,afterVariant:s?.node?.variants?.pageInfo.endCursor},o);return o??[]}catch{return r??[]}};return d(s,[])},fetchMedias=async(e,{id:t,isSample:r,isStorefront:a})=>{let s={orderBy,where:{isSample:r,...a&&{isStorefront:a},...(!t||t&&"latest"==t.toLowerCase())&&{status:"ACTIVE"},...t&&"latest"!==t.toLowerCase()&&{baseID:t}},orderByMedia:{field:"POSITION",direction:"ASC"}},d=async t=>{try{let r=await e([productMedias_generated.ProductMediasDocument,t]),a=r.medias?.edges?.[0],s=a?.node?.medias?.edges??[];if(a?.node?.medias?.pageInfo?.hasNextPage)try{let e=await d({...t,afterMedia:a?.node?.medias?.pageInfo.endCursor});return s.concat(e)}catch{}return s}catch{return[]}};return d(s)};exports.fetchMedias=fetchMedias,exports.fetchVariants=fetchVariants,exports.getProduct=getProduct;
+'use strict';
+
+var productLittleDetail_generated = require('../../graphql/queries/product-little-detail.generated.js');
+var productMedias_generated = require('../../graphql/queries/product-medias.generated.js');
+var productVariants_generated = require('../../graphql/queries/product-variants.generated.js');
+
+const getProduct = async (fetcher, { id, isSample, isStorefront })=>{
+    const [product, variants, medias] = await Promise.all([
+        fetchProduct(fetcher, {
+            id,
+            isSample,
+            isStorefront
+        }),
+        fetchVariants(fetcher, {
+            id,
+            isSample,
+            isStorefront
+        }),
+        fetchMedias(fetcher, {
+            id,
+            isSample,
+            isStorefront
+        })
+    ]);
+    if (!product) {
+        throw new Error('Product not found');
+    }
+    return {
+        ...product,
+        variants: {
+            edges: variants
+        },
+        medias: {
+            edges: medias
+        }
+    };
+};
+const orderBy = {
+    field: 'CREATED_AT',
+    direction: 'DESC'
+};
+const fetchProduct = async (fetcher, { id, isSample, isStorefront })=>{
+    const variables = {
+        orderBy,
+        where: {
+            isSample,
+            ...isStorefront && {
+                isStorefront
+            },
+            ...(!id || id && id.toLowerCase() == 'latest') && {
+                status: 'ACTIVE'
+            },
+            ...id && id.toLowerCase() !== 'latest' && {
+                baseID: id
+            }
+        }
+    };
+    const response = await fetcher([
+        productLittleDetail_generated.ProductLittleDetailDocument,
+        variables
+    ]);
+    return response.product?.edges?.[0]?.node;
+};
+const fetchVariants = async (fetcher, { id, isSample, isStorefront })=>{
+    const initVariables = {
+        orderBy,
+        where: {
+            isSample,
+            ...isStorefront && {
+                isStorefront
+            },
+            ...(!id || id && id.toLowerCase() == 'latest') && {
+                status: 'ACTIVE'
+            },
+            ...id && id.toLowerCase() !== 'latest' && {
+                baseID: id
+            }
+        },
+        orderByVariant: {
+            field: 'POSITION',
+            direction: 'ASC'
+        }
+    };
+    const query = async (variables, olds)=>{
+        try {
+            const response = await fetcher([
+                productVariants_generated.ProductVariantsDocument,
+                variables
+            ]);
+            const product = response.variants?.edges?.[0];
+            const items = olds?.concat(product?.node?.variants?.edges ?? []);
+            if (product?.node?.variants?.pageInfo?.hasNextPage) {
+                return query({
+                    ...variables,
+                    afterVariant: product?.node?.variants?.pageInfo.endCursor
+                }, items);
+            }
+            return items ?? [];
+        } catch  {
+            return olds ?? [];
+        }
+    };
+    return query(initVariables, []);
+};
+const fetchMedias = async (fetcher, { id, isSample, isStorefront })=>{
+    const initVariables = {
+        orderBy,
+        where: {
+            isSample,
+            ...isStorefront && {
+                isStorefront
+            },
+            ...(!id || id && id.toLowerCase() == 'latest') && {
+                status: 'ACTIVE'
+            },
+            ...id && id.toLowerCase() !== 'latest' && {
+                baseID: id
+            }
+        },
+        orderByMedia: {
+            field: 'POSITION',
+            direction: 'ASC'
+        }
+    };
+    const query = async (variables)=>{
+        try {
+            const response = await fetcher([
+                productMedias_generated.ProductMediasDocument,
+                variables
+            ]);
+            const product = response.medias?.edges?.[0];
+            const items = product?.node?.medias?.edges ?? [];
+            if (product?.node?.medias?.pageInfo?.hasNextPage) {
+                try {
+                    const newData = await query({
+                        ...variables,
+                        afterMedia: product?.node?.medias?.pageInfo.endCursor
+                    });
+                    return items.concat(newData);
+                } catch  {
+                    return items;
+                }
+            }
+            return items;
+        } catch  {
+            return [];
+        }
+    };
+    return query(initVariables);
+};
+
+exports.fetchMedias = fetchMedias;
+exports.fetchVariants = fetchVariants;
+exports.getProduct = getProduct;