@ikas/storefront-providers 4.0.0-alpha.78 → 4.0.0-alpha.8

package/src/providers/placeholders.ts

@@ -0,0 +1,138 @@
+import {
+  IkasBlog,
+  IkasBlogCategory,
+  IkasBlogMetaData,
+  IkasBrand,
+  IkasCategory,
+  IkasProduct,
+  IkasProductType,
+  IkasRaffle,
+  IkasRaffleVerificationType,
+} from "@ikas/storefront-models";
+
+export function getPlaceholderProduct() {
+  const product: IkasProduct = {
+    id: "",
+    name: "",
+    type: IkasProductType.PHYSICAL,
+    description: "",
+    shortDescription: "",
+    metaData: null,
+    brand: null,
+    categories: [],
+    tags: [],
+    variants: [],
+    attributes: [],
+    variantTypes: [],
+    productOptionSetId: null,
+  };
+  return product;
+}
+
+export function getPlaceholderCategory() {
+  const category: IkasCategory = {
+    categoryPath: [],
+    description: null,
+    imageId: null,
+    name: "",
+    parentId: null,
+    metaData: null,
+    categoryPathItems: [],
+    orderType: null,
+    id: "",
+    createdAt: 0,
+    updatedAt: 0,
+  };
+  return category;
+}
+
+export function getPlaceholderBrand() {
+  const brand: IkasBrand = {
+    description: null,
+    imageId: null,
+    metaData: null,
+    orderType: null,
+    name: "",
+    id: "",
+    createdAt: 0,
+    updatedAt: 0,
+  };
+  return brand;
+}
+
+export function getPlaceholderBlog() {
+  const blog: IkasBlog = {
+    createdAt: 0,
+    id: "",
+    updatedAt: 0,
+    blogContent: {
+      content: "",
+      createdAt: 0,
+      id: "",
+      updatedAt: 0,
+    },
+    categoryId: "",
+    imageId: "",
+    isPublished: false,
+    locale: null,
+    metadata: getPlaceholderBlogMetaData(),
+    publishedAt: null,
+    shortDescription: "",
+    storefrontId: "",
+    tagIds: [],
+    tags: [],
+    title: "",
+    writer: {
+      firstName: "",
+      lastName: "",
+    },
+    category: getPlaceholderBlogCategory(),
+  };
+  return blog;
+}
+
+export function getPlaceholderBlogCategory() {
+  const blogCategory: IkasBlogCategory = {
+    createdAt: 0,
+    id: "",
+    updatedAt: 0,
+    imageId: "",
+    metadata: getPlaceholderBlogMetaData(),
+    name: "",
+  };
+  return blogCategory;
+}
+
+export function getPlaceholderRaffle(): IkasRaffle {
+  return {
+    createdAt: 0,
+    id: "",
+    updatedAt: 0,
+    deleted: false,
+    dateRange: null,
+    metadata: null,
+    name: "",
+    participantCount: null,
+    requiredCustomerAccount: false,
+    status: false,
+    variants: [],
+    products: [],
+    verificationType: IkasRaffleVerificationType.EMAIL,
+    isCustomerWinner: false,
+  };
+}
+
+function getPlaceholderBlogMetaData(): IkasBlogMetaData {
+  return {
+    canonicals: [],
+    description: "",
+    disableIndex: false,
+    pageTitle: null,
+    slug: "",
+    targetId: null,
+    targetType: null,
+    createdAt: 0,
+    id: "",
+    updatedAt: 0,
+  };
+}

package/src/providers/prop-value/attribute-list.ts

@@ -0,0 +1,75 @@
+import IkasPropValueProvider from ".";
+import { IkasProduct } from "@ikas/storefront-models";
+import { searchProducts } from "@ikas/storefront-api";
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+import { IkasAttributeListPropValue } from "../../models/prop-value/attribute-list";
+import { IkasProductFunctions } from "@ikas/storefront-model-functions";
+import { IkasAttributeListPropValueData } from "../types";
+
+export class IkasAttributeListPropValueProvider
+  implements IkasPropValueProvider<IkasAttributeListPropValueData>
+{
+  private attributeListPropValue: IkasAttributeListPropValue;
+
+  constructor(prop: IkasAttributeListPropValue) {
+    this.attributeListPropValue = prop;
+  }
+
+  async getValue(): Promise<IkasAttributeListPropValueData> {
+    if (
+      !this.attributeListPropValue.attributeIds?.length ||
+      this.attributeListPropValue.usePageData ||
+      (!this.attributeListPropValue.usePageData &&
+        !this.attributeListPropValue.variantId)
+    ) {
+      return {
+        productDetail: null,
+        attributeListPropValue: this.attributeListPropValue,
+      };
+    }
+
+    let productDetail: IkasProduct | undefined;
+
+    const productSearchResponse = await searchProducts({
+      input: {
+        productIdList: [this.attributeListPropValue.productId!],
+        priceListId: IkasStorefrontConfig.getPriceListId(),
+        salesChannelId: IkasStorefrontConfig.getSalesChannelId(),
+      },
+    });
+
+    if (productSearchResponse.isSuccess && productSearchResponse.data?.data) {
+      const productList = productSearchResponse.data.data;
+      const { hasVariant } = IkasProductFunctions;
+
+      if (productList.length) {
+        const product = productList[0];
+
+        if (product && hasVariant(product)) {
+          const variant = product.variants.find(
+            (v) => v.id === this.attributeListPropValue.variantId
+          );
+
+          if (variant) {
+            //@ts-ignore
+            product.selectedVariantValues = variant.variantValues;
+            productDetail = product;
+          }
+        } else {
+          const selectedVariant = product.variants.find((v) => v.isActive);
+          //@ts-ignore
+          product.selectedVariantValues = (
+            selectedVariant || product.variants[0]
+          ).variantValues;
+
+          productDetail = product;
+        }
+      }
+    }
+
+    return {
+      productDetail: productDetail || null,
+      attributeListPropValue: this.attributeListPropValue,
+    };
+  }
+}

package/src/providers/prop-value/attribute.ts

@@ -0,0 +1,77 @@
+import { searchProducts } from "@ikas/storefront-api";
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+import { IkasProduct } from "@ikas/storefront-models";
+import IkasPropValueProvider from ".";
+import { IkasAttributePropValue } from "../../models/prop-value/attribute";
+import { IkasProductFunctions } from "@ikas/storefront-model-functions";
+import {
+  IkasAttributePropValueData,
+  IkasProductPropValueProduct,
+} from "../types";
+
+export class IkasAttributePropValueProvider
+  implements IkasPropValueProvider<IkasAttributePropValueData>
+{
+  private attributePropValue: IkasAttributePropValue;
+
+  constructor(prop: IkasAttributePropValue) {
+    this.attributePropValue = prop;
+  }
+
+  async getValue(): Promise<IkasAttributePropValueData> {
+    if (
+      !this.attributePropValue.attributeId ||
+      this.attributePropValue?.usePageData ||
+      (!this.attributePropValue.usePageData &&
+        !this.attributePropValue.variantId)
+    ) {
+      return {
+        productDetail: null,
+        attributePropValue: this.attributePropValue,
+      };
+    }
+
+    let productDetail: IkasProduct | undefined;
+
+    const productSearchResponse = await searchProducts({
+      input: {
+        productIdList: [this.attributePropValue.productId!],
+        priceListId: IkasStorefrontConfig.getPriceListId(),
+        salesChannelId: IkasStorefrontConfig.getSalesChannelId(),
+      },
+    });
+
+    if (productSearchResponse.isSuccess && productSearchResponse.data?.data) {
+      const productList: IkasProductPropValueProduct[] =
+        productSearchResponse.data.data;
+
+      if (productList.length) {
+        const product = productList[0];
+        const { hasVariant } = IkasProductFunctions;
+
+        if (product && hasVariant(product)) {
+          const variant = product.variants.find(
+            (v) => v.id === this.attributePropValue.variantId
+          );
+
+          if (variant) {
+            product.selectedVariantValues = variant.variantValues;
+            productDetail = product;
+          }
+        } else {
+          const selectedVariant = product.variants.find((v) => v.isActive);
+          product.selectedVariantValues = (
+            selectedVariant || product.variants[0]
+          ).variantValues;
+
+          productDetail = product;
+        }
+      }
+    }
+
+    return {
+      productDetail: productDetail || null,
+      attributePropValue: this.attributePropValue,
+    };
+  }
+}

package/src/providers/prop-value/blog-category-list.ts

@@ -0,0 +1,29 @@
+import IkasPropValueProvider from ".";
+import { IkasBlogCategoryListPropValue } from "../../models/prop-value/blog-category-list";
+import { IkasBlogCategoryList } from "../../models/ui";
+import { getInitial } from "../../models/ui/blog-category-list/init";
+
+export class IkasBlogCategoryListPropValueProvider
+  implements IkasPropValueProvider<IkasBlogCategoryList>
+{
+  private blogCategoryListPropValue: IkasBlogCategoryListPropValue;
+
+  constructor(blogCategoryListPropValue: IkasBlogCategoryListPropValue) {
+    this.blogCategoryListPropValue = blogCategoryListPropValue;
+  }
+
+  async getValue(): Promise<IkasBlogCategoryList> {
+    const blogCategoryList: IkasBlogCategoryList = {
+      data: [],
+      count: 0,
+      page: 1,
+      limit: 10,
+      blogCategoryListPropValue: this.blogCategoryListPropValue,
+      type: this.blogCategoryListPropValue.blogCategoryListType,
+    };
+
+    await getInitial(blogCategoryList);
+
+    return blogCategoryList;
+  }
+}

package/src/providers/prop-value/blog-category.ts

@@ -0,0 +1,49 @@
+import { listBlogCategory } from "@ikas/storefront-api";
+import IkasPropValueProvider from ".";
+import { IkasBlogCategoryPropValue } from "../../models/prop-value/blog-category";
+import { getPlaceholderBlogCategory } from "../placeholders";
+import { IkasBlogCategoryPropValueData } from "../types";
+
+export class IkasBlogCategoryPropValueProvider
+  implements IkasPropValueProvider<IkasBlogCategoryPropValueData | null>
+{
+  private blogCategoryPropValue: IkasBlogCategoryPropValue;
+
+  constructor(propValue: IkasBlogCategoryPropValue) {
+    this.blogCategoryPropValue = propValue;
+  }
+
+  async getValue(): Promise<IkasBlogCategoryPropValueData | null> {
+    if (this.blogCategoryPropValue?.usePageData) {
+      return {
+        blogCategory: null,
+        blogCategoryPropValue: this.blogCategoryPropValue,
+      };
+    }
+    if (!this.blogCategoryPropValue.blogCategoryId) return null;
+
+    const listBlogCategoryResponse = await listBlogCategory({
+      id: { eq: this.blogCategoryPropValue.blogCategoryId },
+      pagination: {
+        page: 1,
+        limit: 1,
+      },
+    });
+
+    if (
+      listBlogCategoryResponse.isSuccess &&
+      listBlogCategoryResponse.data?.data
+    ) {
+      return {
+        blogCategory:
+          listBlogCategoryResponse.data.data[0] || getPlaceholderBlogCategory(),
+        blogCategoryPropValue: this.blogCategoryPropValue,
+      };
+    } else {
+      return {
+        blogCategory: getPlaceholderBlogCategory(),
+        blogCategoryPropValue: this.blogCategoryPropValue,
+      };
+    }
+  }
+}

package/src/providers/prop-value/blog-list.ts

@@ -0,0 +1,61 @@
+import {
+  IkasBlogCategory,
+  IkasThemeJsonPageType,
+} from "@ikas/storefront-models";
+import IkasPropValueProvider from ".";
+import { IkasBlogListPropValue } from "../../models/prop-value/blog-list";
+import { IkasBlogList, IkasBlogListType } from "../../models/ui";
+import { getInitial } from "../../models/ui/blog-list/init";
+
+export class IkasBlogListPropValueProvider
+  implements IkasPropValueProvider<IkasBlogList>
+{
+  private pageType: IkasThemeJsonPageType;
+  private blogListPropValue: IkasBlogListPropValue;
+  private pageSpecificData?: any;
+
+  constructor(
+    pageType: IkasThemeJsonPageType,
+    blogListPropValue: IkasBlogListPropValue,
+    pageSpecificData?: any
+  ) {
+    this.pageType = pageType;
+    this.blogListPropValue = blogListPropValue;
+    this.pageSpecificData = pageSpecificData;
+  }
+
+  async getValue(): Promise<IkasBlogList> {
+    let filterCategoryId: string | null = null;
+
+    if (
+      this.blogListPropValue.blogListType === IkasBlogListType.ALL &&
+      this.blogListPropValue.usePageFilter &&
+      this.pageType === IkasThemeJsonPageType.BLOG_CATEGORY &&
+      this.pageSpecificData
+    ) {
+      const blogCategory = this.pageSpecificData as IkasBlogCategory;
+      filterCategoryId = blogCategory.id;
+    }
+
+    if (
+      this.blogListPropValue.blogListType === IkasBlogListType.CATEGORY &&
+      this.blogListPropValue.categoryId
+    ) {
+      filterCategoryId = this.blogListPropValue.categoryId;
+    }
+
+    const blogList: IkasBlogList = {
+      data: [],
+      count: 0,
+      type: this.blogListPropValue.blogListType,
+      page: 1,
+      limit: this.blogListPropValue.initialLimit || 10,
+      blogListPropValue: this.blogListPropValue,
+      filterCategoryId,
+    };
+
+    await getInitial(blogList);
+
+    return blogList;
+  }
+}

package/src/providers/prop-value/blog.ts

@@ -0,0 +1,41 @@
+import { listBlog } from "@ikas/storefront-api";
+import IkasPropValueProvider from ".";
+import { IkasBlogPropValue } from "../../models/prop-value/blog";
+import { getPlaceholderBlog } from "../placeholders";
+import { IkasBlogPropValueData } from "../types";
+
+export class IkasBlogPropValueProvider
+  implements IkasPropValueProvider<IkasBlogPropValueData | null>
+{
+  private blogPropValue: IkasBlogPropValue;
+
+  constructor(propValue: IkasBlogPropValue) {
+    this.blogPropValue = propValue;
+  }
+
+  async getValue(): Promise<IkasBlogPropValueData | null> {
+    if (this.blogPropValue?.usePageData) {
+      return {
+        blog: null,
+        blogPropValue: this.blogPropValue,
+      };
+    }
+    if (!this.blogPropValue.blogId) return null;
+
+    const listBlogResponse = await listBlog({
+      id: { eq: this.blogPropValue.blogId },
+    });
+
+    if (listBlogResponse.isSuccess && listBlogResponse.data?.data?.length) {
+      return {
+        blog: listBlogResponse.data.data[0] || getPlaceholderBlog(),
+        blogPropValue: this.blogPropValue,
+      };
+    } else {
+      return {
+        blog: getPlaceholderBlog(),
+        blogPropValue: this.blogPropValue,
+      };
+    }
+  }
+}

package/src/providers/prop-value/boolean.ts

@@ -0,0 +1,14 @@
+import IkasPropValueProvider from ".";
+
+export class IkasBooleanPropValueProvider
+  implements IkasPropValueProvider<boolean> {
+  private bool: boolean;
+
+  constructor(boolPropValue: boolean) {
+    this.bool = boolPropValue;
+  }
+
+  async getValue(): Promise<boolean> {
+    return this.bool || false;
+  }
+}

package/src/providers/prop-value/brand-list.ts

@@ -0,0 +1,30 @@
+import IkasPropValueProvider from ".";
+import { IkasBrandListPropValue } from "../../models/prop-value/brand-list";
+import { IkasBrandList, IkasBrandListSortType } from "../../models/ui";
+import { getInitial } from "../../models/ui/brand-list/init";
+
+export class IkasBrandListPropValueProvider
+  implements IkasPropValueProvider<IkasBrandList>
+{
+  private brandListPropValue: IkasBrandListPropValue;
+
+  constructor(brandListPropValue: IkasBrandListPropValue) {
+    this.brandListPropValue = brandListPropValue;
+  }
+
+  async getValue(): Promise<IkasBrandList> {
+    const brandList: IkasBrandList = {
+      data: [],
+      count: 0,
+      type: this.brandListPropValue.brandListType,
+      sort: this.brandListPropValue.initialSort || IkasBrandListSortType.A_Z,
+      page: 1,
+      limit: this.brandListPropValue.initialLimit || 10,
+      brandListPropValue: this.brandListPropValue,
+    };
+
+    await getInitial(brandList);
+
+    return brandList;
+  }
+}

package/src/providers/prop-value/brand.ts

@@ -0,0 +1,46 @@
+import { listProductBrand } from "@ikas/storefront-api";
+import IkasPropValueProvider from ".";
+import { IkasBrandPropValue } from "../../models/prop-value/brand";
+import { getPlaceholderBrand } from "../placeholders";
+import { IkasBrandPropValueData } from "../types";
+
+export class IkasBrandPropValueProvider
+  implements IkasPropValueProvider<IkasBrandPropValueData | null>
+{
+  private brandPropValue: IkasBrandPropValue;
+
+  constructor(prop: IkasBrandPropValue) {
+    this.brandPropValue = prop;
+  }
+
+  async getValue(): Promise<IkasBrandPropValueData | null> {
+    if (this.brandPropValue.usePageData) {
+      return {
+        brand: null,
+        brandPropValue: this.brandPropValue,
+      };
+    }
+    if (!this.brandPropValue.brandId) return null;
+
+    try {
+      const listBrandResponse = await listProductBrand({
+        id: { eq: this.brandPropValue.brandId },
+      });
+
+      if (listBrandResponse.isSuccess && listBrandResponse.data?.data) {
+        const brand = listBrandResponse.data.data.length
+          ? listBrandResponse.data.data[0]
+          : getPlaceholderBrand();
+
+        return {
+          brand,
+          brandPropValue: this.brandPropValue,
+        };
+      }
+    } catch (err) {
+      console.log(err);
+    }
+
+    return null;
+  }
+}

package/src/providers/prop-value/category-list.ts

@@ -0,0 +1,31 @@
+import IkasPropValueProvider from ".";
+import { IkasCategoryListPropValue } from "../../models/prop-value/category-list";
+import { IkasCategoryList, IkasCategoryListSortType } from "../../models/ui";
+import { getInitial } from "../../models/ui/category-list/init";
+
+export class IkasCategoryListPropValueProvider
+  implements IkasPropValueProvider<IkasCategoryList>
+{
+  private categoryListPropValue: IkasCategoryListPropValue;
+
+  constructor(categoryListPropValue: IkasCategoryListPropValue) {
+    this.categoryListPropValue = categoryListPropValue;
+  }
+
+  async getValue(): Promise<IkasCategoryList> {
+    const categoryList: IkasCategoryList = {
+      data: [],
+      count: 0,
+      type: this.categoryListPropValue.categoryListType,
+      sort:
+        this.categoryListPropValue.initialSort || IkasCategoryListSortType.A_Z,
+      page: 1,
+      limit: this.categoryListPropValue.initialLimit || 10,
+      categoryListPropValue: this.categoryListPropValue,
+    };
+
+    await getInitial(categoryList);
+
+    return categoryList;
+  }
+}

package/src/providers/prop-value/category.ts

@@ -0,0 +1,45 @@
+import { listCategory } from "@ikas/storefront-api";
+import { IkasCategory } from "@ikas/storefront-models";
+import IkasPropValueProvider from ".";
+import { IkasCategoryPropValue } from "../../models/prop-value/category";
+import { getPlaceholderCategory } from "../placeholders";
+import { IkasCategoryPropValueData } from "../types";
+
+export class IkasCategoryPropValueProvider
+  implements IkasPropValueProvider<IkasCategoryPropValueData | null>
+{
+  private categoryPropValue: IkasCategoryPropValue;
+
+  constructor(prop: IkasCategoryPropValue) {
+    this.categoryPropValue = prop;
+  }
+
+  async getValue(): Promise<IkasCategoryPropValueData | null> {
+    if (this.categoryPropValue.usePageData) {
+      return {
+        category: null,
+        categoryPropValue: this.categoryPropValue,
+      };
+    }
+    if (!this.categoryPropValue.categoryId) return null;
+
+    try {
+      const response = await listCategory({
+        id: { eq: this.categoryPropValue.categoryId },
+      });
+
+      const category: IkasCategory = response.data?.data?.length
+        ? response.data.data[0]
+        : getPlaceholderCategory();
+
+      return {
+        category,
+        categoryPropValue: this.categoryPropValue,
+      };
+    } catch (err) {
+      console.log(err);
+    }
+
+    return null;
+  }
+}

package/src/providers/prop-value/color.ts

@@ -0,0 +1,14 @@
+import IkasPropValueProvider from ".";
+
+export class IkasColorPropValueProvider
+  implements IkasPropValueProvider<string> {
+  private color: string;
+
+  constructor(colorPropValue: string) {
+    this.color = colorPropValue;
+  }
+
+  async getValue(): Promise<string> {
+    return this.color;
+  }
+}