@ikas/storefront-providers 4.0.0-alpha.10

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@ikas/storefront-providers",
+  "version": "4.0.0-alpha.10",
+  "description": "Data providers for ikas storefront theme components.",
+  "author": "Umut Ozan Yıldırım",
+  "license": "ISC",
+  "main": "./src/index.ts",
+  "module": "./src/index.ts",
+  "files": [
+    "./src"
+  ],
+  "type": "module",
+  "scripts": {
+    "pack": "npm pack",
+    "release": "npm publish",
+    "build": "rm -rf build && rollup -c"
+  },
+  "devDependencies": {
+    "@rollup/plugin-commonjs": "^22.0.0",
+    "@ikas/storefront-api": "^4.0.0-alpha.10",
+    "@ikas/storefront-config": "^4.0.0-alpha.10",
+    "@ikas/storefront-model-functions": "^4.0.0-alpha.10",
+    "@ikas/storefront-models": "^4.0.0-alpha.10",
+    "@rollup/plugin-node-resolve": "^13.3.0",
+    "@types/lodash": "^4.14.168",
+    "@types/react": "^16.9.55",
+    "mobx": "^6.1.3",
+    "prettier": "^2.2.1",
+    "rollup": "^2.75.6",
+    "rollup-plugin-terser": "^7.0.2",
+    "rollup-plugin-typescript2": "^0.32.1",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "typescript": "^4.7.2",
+    "ttypescript": "^1.5.12",
+    "typescript-transform-paths": "^2.2.2",
+    "lodash": "^4.17.20"
+  },
+  "peerDependencies": {
+    "mobx": "^6.1.3",
+    "@ikas/storefront-api": "^4.0.0-alpha.10",
+    "@ikas/storefront-config": "^4.0.0-alpha.10",
+    "@ikas/storefront-model-functions": "^4.0.0-alpha.10",
+    "@ikas/storefront-models": "^4.0.0-alpha.10",
+    "lodash": "^4.17.20"
+  }
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+export * from "./models/prop-value/attribute";
+export * from "./models/prop-value/attribute-list";
+export * from "./models/prop-value/blog-category-list";
+export * from "./models/prop-value/blog-category";
+export * from "./models/prop-value/blog-list";
+export * from "./models/prop-value/blog";
+export * from "./models/prop-value/brand-list";
+export * from "./models/prop-value/brand";
+export * from "./models/prop-value/category-list";
+export * from "./models/prop-value/category";
+export * from "./models/prop-value/link";
+export * from "./models/prop-value/product-list";
+export * from "./models/prop-value/product";
+export * from "./models/prop-value/raffle-list";
+export * from "./models/prop-value/raffle";
+
+export * from "./models/ui";
+
+export { IkasPageDataProvider } from "./providers/page-data-get";
+export * from "./providers/types";
+export * from "./providers/placeholders";
+export * from "./providers/helpers/raffle";

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

@@ -0,0 +1,8 @@
+export type IkasAttributeListPropValue = {
+  attributeIds?: string[] | null;
+  productId?: string | null;
+  variantId?: string | null;
+
+  // Only for product detail page
+  usePageData?: boolean | null;
+};

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

@@ -0,0 +1,8 @@
+export type IkasAttributePropValue = {
+  attributeId?: string | null;
+  productId?: string | null;
+  variantId?: string | null;
+
+  // Only for product detail page
+  usePageData?: boolean | null;
+};

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

@@ -0,0 +1,9 @@
+import { IkasBlogCategoryListType } from "../ui";
+
+export type IkasBlogCategoryListPropValue = {
+  blogCategoryListType: IkasBlogCategoryListType;
+  initialLimit?: number | null;
+
+  // Only for static lists
+  blogCategoryIds?: string[] | null;
+};

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

@@ -0,0 +1,6 @@
+export type IkasBlogCategoryPropValue = {
+  blogCategoryId?: string | null;
+
+  // Only for product detail page
+  usePageData?: boolean | null;
+};

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

@@ -0,0 +1,13 @@
+import { IkasBlogListType } from "../ui";
+
+export type IkasBlogListPropValue = {
+  blogListType: IkasBlogListType;
+  initialLimit?: number | null;
+
+  // Only for static lists
+  blogIds?: string[] | null;
+
+  // For CATEGORY type only
+  categoryId: string | null;
+  usePageFilter?: boolean | null;
+};

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

@@ -0,0 +1,6 @@
+export type IkasBlogPropValue = {
+  blogId?: string | null;
+
+  // Only for product detail page
+  usePageData?: boolean | null;
+};

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

@@ -0,0 +1,11 @@
+import { IkasBrandListSortType, IkasBrandListType } from "../ui";
+
+export type IkasBrandListPropValue = {
+  brandListType: IkasBrandListType;
+  initialSort?: IkasBrandListSortType | null;
+  initialLimit?: number | null;
+
+  // Only for static lists
+  brandCount?: number | null;
+  brandIds?: string[] | null;
+};

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

@@ -0,0 +1,6 @@
+export class IkasBrandPropValue {
+  brandId?: string | null;
+
+  // Only for brand detail page
+  usePageData?: boolean | null;
+}

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

@@ -0,0 +1,11 @@
+import { IkasCategoryListSortType, IkasCategoryListType } from "../ui";
+
+export type IkasCategoryListPropValue = {
+  categoryListType: IkasCategoryListType;
+  initialSort?: IkasCategoryListSortType | null;
+  initialLimit?: number | null;
+
+  // Only for static lists
+  categoryCount?: number | null;
+  categoryIds?: string[] | null;
+};

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

@@ -0,0 +1,6 @@
+export type IkasCategoryPropValue = {
+  categoryId?: string | null;
+
+  // Only for category detail page
+  usePageData?: boolean | null;
+};

package/src/models/prop-value/link.ts

@@ -0,0 +1,22 @@
+import { IkasThemeJsonPageType } from "@ikas/storefront-models";
+
+export type IkasLinkPropValue = {
+  id?: string | null;
+  linkType?: IkasLinkType | null;
+  label?: string | null;
+  pageId?: string | null;
+  pageType?: IkasThemeJsonPageType | null;
+  itemId?: string | null;
+  externalLink?: string | null;
+  fileUrl?: string | null;
+
+  // This will be used to link to a specific part of the page
+  pageComponentId?: string | null;
+  subLinks: IkasLinkPropValue[];
+};
+
+export enum IkasLinkType {
+  PAGE = "PAGE",
+  EXTERNAL = "EXTERNAL",
+  FILE = "FILE",
+}

package/src/models/prop-value/product-list.ts

@@ -0,0 +1,29 @@
+import {
+  IkasProductListSortType,
+  IkasProductListType,
+  IkasRelatedProductsType,
+} from "../ui";
+
+export type IkasProductListPropValue = {
+  id: string;
+  productListType: IkasProductListType;
+  initialSort?: IkasProductListSortType | null;
+  initialLimit?: number | null;
+
+  // Only for static lists
+  productCount?: number | null;
+  productIds?: IkasProductVariantId[] | null;
+
+  // Only for collection and brand pages
+  // Example collections/man -> lists products inside the "man" category
+  usePageFilter?: boolean | null;
+  category?: string | null;
+
+  // Only for related products
+  relatedProductsType?: IkasRelatedProductsType | null;
+};
+
+type IkasProductVariantId = {
+  productId: string;
+  variantId: string;
+};

package/src/models/prop-value/product.ts

@@ -0,0 +1,7 @@
+export type IkasProductPropValue = {
+  productId?: string | null;
+  variantId?: string | null;
+
+  // Only for product detail page
+  usePageData?: boolean | null;
+};

package/src/models/prop-value/raffle-list.ts

@@ -0,0 +1,6 @@
+export type IkasRaffleListPropValue = {
+  initialLimit?: number | null;
+
+  // Only for static lists
+  raffleIds?: string[] | null;
+};

package/src/models/prop-value/raffle.ts

@@ -0,0 +1,6 @@
+export type IkasRafflePropValue = {
+  raffleId?: string | null;
+
+  // Only for raffle detail page
+  usePageData?: boolean | null;
+};

package/src/models/ui/blog-category-list/index.ts

@@ -0,0 +1,19 @@
+import { IkasBlogCategory } from "@ikas/storefront-models";
+import { IkasBlogCategoryListPropValue } from "../../prop-value/blog-category-list";
+
+export type IkasBlogCategoryList = {
+  data: IkasBlogCategory[];
+  type: IkasBlogCategoryListType;
+  limit: number;
+  page: number;
+  count: number;
+  initialized?: boolean;
+  minPage?: number | null;
+  blogCategoryListPropValue: IkasBlogCategoryListPropValue;
+  isLoading?: boolean;
+};
+
+export enum IkasBlogCategoryListType {
+  ALL = "ALL",
+  STATIC = "STATIC",
+}

package/src/models/ui/blog-category-list/init.ts

@@ -0,0 +1,54 @@
+import { listBlogCategory } from "@ikas/storefront-api";
+import { IkasBlogCategory } from "@ikas/storefront-models";
+import { IkasBlogCategoryList, IkasBlogCategoryListType } from ".";
+
+export async function getInitial(list: IkasBlogCategoryList) {
+  try {
+    const response = await listBlogCategories(
+      list,
+      isStatic(list) ? 1 : list.page,
+      isStatic(list)
+        ? list.blogCategoryListPropValue.blogCategoryIds?.length || 10
+        : list.limit
+    );
+
+    if (isStatic(list)) {
+      list.data =
+        (list.blogCategoryListPropValue.blogCategoryIds
+          ?.map((bID) => {
+            return response.data?.data?.find((b) => b.id === bID);
+          })
+          .filter((b) => !!b) as IkasBlogCategory[]) || [];
+    } else {
+      list.data = response.data?.data || [];
+    }
+
+    list.count = response.data?.count || 0;
+    list.initialized = true;
+    list.minPage = list.page;
+  } catch (err) {
+    console.error(err);
+  }
+}
+
+function isStatic(list: IkasBlogCategoryList) {
+  return list.type === IkasBlogCategoryListType.STATIC;
+}
+
+async function listBlogCategories(
+  list: IkasBlogCategoryList,
+  page: number,
+  limit: number
+) {
+  return await listBlogCategory({
+    id: isStatic(list)
+      ? list.blogCategoryListPropValue.blogCategoryIds
+        ? { in: list.blogCategoryListPropValue.blogCategoryIds }
+        : undefined
+      : undefined,
+    pagination: {
+      page,
+      limit,
+    },
+  });
+}

package/src/models/ui/blog-list/index.ts

@@ -0,0 +1,21 @@
+import { IkasBlog } from "@ikas/storefront-models";
+import { IkasBlogListPropValue } from "../../prop-value/blog-list";
+
+export type IkasBlogList = {
+  data: IkasBlog[];
+  type: IkasBlogListType;
+  limit: number;
+  page: number;
+  count: number;
+  initialized?: boolean;
+  minPage?: number | null;
+  blogListPropValue: IkasBlogListPropValue;
+  filterCategoryId: string | null;
+  isLoading?: boolean;
+};
+
+export enum IkasBlogListType {
+  ALL = "ALL",
+  STATIC = "STATIC",
+  CATEGORY = "CATEGORY",
+}

package/src/models/ui/blog-list/init.ts

@@ -0,0 +1,49 @@
+import { listBlog } from "@ikas/storefront-api";
+import { IkasBlog } from "@ikas/storefront-models";
+import { IkasBlogList, IkasBlogListType } from ".";
+
+export async function getInitial(list: IkasBlogList) {
+  try {
+    const response = await listBlogs(
+      list,
+      isStatic(list) ? 1 : list.page,
+      isStatic(list) ? list.blogListPropValue.blogIds?.length || 10 : list.limit
+    );
+
+    if (isStatic(list)) {
+      list.data =
+        (list.blogListPropValue.blogIds
+          ?.map((bID) => {
+            return response.data?.data?.find((b) => b.id === bID);
+          })
+          .filter((b) => !!b) as IkasBlog[]) || [];
+    } else {
+      list.data = response.data?.data || [];
+    }
+
+    list.count = response.data?.count || 0;
+    list.initialized = true;
+    list.minPage = list.page;
+  } catch (err) {
+    console.error(err);
+  }
+}
+
+function isStatic(list: IkasBlogList) {
+  return list.type === IkasBlogListType.STATIC;
+}
+
+async function listBlogs(list: IkasBlogList, page: number, limit: number) {
+  const response = await listBlog({
+    id: isStatic(list) ? { in: list.blogListPropValue.blogIds } : undefined,
+    pagination: {
+      page,
+      limit,
+    },
+    categoryId: list.filterCategoryId
+      ? { eq: list.filterCategoryId }
+      : undefined,
+  });
+
+  return response;
+}

package/src/models/ui/brand-list/index.ts

@@ -0,0 +1,25 @@
+import { IkasBrand } from "@ikas/storefront-models";
+import { IkasBrandListPropValue } from "../../prop-value/brand-list";
+
+export type IkasBrandList = {
+  data: IkasBrand[];
+  type: IkasBrandListType;
+  sort: IkasBrandListSortType;
+  limit: number;
+  page: number;
+  count: number;
+  initialized?: boolean;
+  minPage?: number | null;
+  brandListPropValue: IkasBrandListPropValue;
+  isLoading?: boolean;
+};
+
+export enum IkasBrandListType {
+  ALL = "ALL",
+  STATIC = "STATIC",
+}
+
+export enum IkasBrandListSortType {
+  A_Z = "A_Z",
+  Z_A = "Z_A",
+}

package/src/models/ui/brand-list/init.ts

@@ -0,0 +1,47 @@
+import { listProductBrand } from "@ikas/storefront-api";
+import { IkasBrand } from "@ikas/storefront-models";
+import { IkasBrandList, IkasBrandListSortType, IkasBrandListType } from ".";
+
+export async function getInitial(list: IkasBrandList) {
+  try {
+    const _isStatic = isStatic(list);
+    const response = await listProductBrand({
+      id: _isStatic
+        ? list.brandListPropValue.brandIds
+          ? { in: list.brandListPropValue.brandIds }
+          : undefined
+        : undefined,
+      pagination: {
+        page: _isStatic ? undefined : list.page,
+        limit: _isStatic ? undefined : list.limit,
+      },
+      sort: getSortParams(list),
+    });
+
+    if (_isStatic) {
+      list.data =
+        (list.brandListPropValue.brandIds
+          ?.map((bID) => {
+            return response.data?.data?.find((b) => b.id === bID);
+          })
+          .filter((b) => !!b) as IkasBrand[]) || [];
+    } else {
+      list.data = response.data?.data || [];
+    }
+
+    list.count = response.data?.count || 0;
+    list.initialized = true;
+    list.minPage = list.page;
+  } catch (err) {
+    console.error(err);
+  }
+}
+
+function isStatic(list: IkasBrandList) {
+  return list.type === IkasBrandListType.STATIC;
+}
+
+function getSortParams(list: IkasBrandList) {
+  if (list.sort === IkasBrandListSortType.A_Z) return "name";
+  else return "-name";
+}

package/src/models/ui/category-list/index.ts

@@ -0,0 +1,25 @@
+import { IkasCategory } from "@ikas/storefront-models";
+import { IkasCategoryListPropValue } from "../../prop-value/category-list";
+
+export type IkasCategoryList = {
+  data: IkasCategory[];
+  type: IkasCategoryListType;
+  sort: IkasCategoryListSortType;
+  limit: number;
+  page: number;
+  count: number;
+  initialized?: boolean;
+  minPage?: number | null;
+  categoryListPropValue: IkasCategoryListPropValue;
+  isLoading?: boolean;
+};
+
+export enum IkasCategoryListType {
+  ALL = "ALL",
+  STATIC = "STATIC",
+}
+
+export enum IkasCategoryListSortType {
+  A_Z = "A_Z",
+  Z_A = "Z_A",
+}

package/src/models/ui/category-list/init.ts

@@ -0,0 +1,50 @@
+import { listCategory } from "@ikas/storefront-api";
+import { IkasCategory } from "@ikas/storefront-models";
+import {
+  IkasCategoryList,
+  IkasCategoryListSortType,
+  IkasCategoryListType,
+} from ".";
+
+export async function getInitial(list: IkasCategoryList) {
+  try {
+    const response = await listCategory({
+      id: isStatic(list)
+        ? list.categoryListPropValue.categoryIds
+          ? { in: list.categoryListPropValue.categoryIds }
+          : undefined
+        : undefined,
+      pagination: {
+        page: isStatic(list) ? undefined : list.page,
+        limit: isStatic(list) ? undefined : list.limit,
+      },
+      sort: getSortParams(list),
+    });
+
+    if (isStatic(list)) {
+      list.data =
+        (list.categoryListPropValue.categoryIds
+          ?.map((cID) => {
+            return response.data?.data?.find((c) => c.id === cID);
+          })
+          .filter((c) => !!c) as IkasCategory[]) || [];
+    } else {
+      list.data = response.data?.data || [];
+    }
+
+    list.count = response.data?.count || 0;
+    list.initialized = true;
+    list.minPage = list.page;
+  } catch (err) {
+    console.error(err);
+  }
+}
+
+function isStatic(list: IkasCategoryList) {
+  return list.type === IkasCategoryListType.STATIC;
+}
+
+function getSortParams(list: IkasCategoryList) {
+  if (list.sort === IkasCategoryListSortType.A_Z) return "name";
+  else return "-name";
+}

package/src/models/ui/component-renderer/index.ts

@@ -0,0 +1,5 @@
+type RenderFunction = () => React.ReactNode;
+
+export type IkasComponentRenderer = {
+  render: RenderFunction;
+};

package/src/models/ui/customer-review-list/index.ts

@@ -0,0 +1,12 @@
+import { IkasCustomerReview } from "@ikas/storefront-models";
+
+export type IkasCustomerReviewList = {
+  data: IkasCustomerReview[];
+  limit: number;
+  page: number;
+  count: number;
+  initialized?: boolean;
+  minPage?: number | null;
+  productId: string;
+  isLoading?: boolean;
+};

package/src/models/ui/customer-review-list/init.ts

@@ -0,0 +1,33 @@
+import { listCustomerReviews } from "@ikas/storefront-api";
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+import { IkasCustomerReviewList } from ".";
+
+export async function getInitial(list: IkasCustomerReviewList) {
+  try {
+    const response = await _listCustomerReviews(list, list.page, list.limit);
+
+    list.data = response.data?.data || [];
+    list.count = response.data?.count || 0;
+    list.initialized = true;
+    list.minPage = list.page;
+  } catch (err) {
+    console.error(err);
+  }
+}
+
+async function _listCustomerReviews(
+  list: IkasCustomerReviewList,
+  page: number,
+  limit: number
+) {
+  return await listCustomerReviews({
+    productId: list.productId,
+    input: {
+      salesChannelId: IkasStorefrontConfig.getSalesChannelId() || "",
+    },
+    pagination: {
+      page,
+      limit,
+    },
+  });
+}

package/src/models/ui/customer-review-summary-list/index.ts

@@ -0,0 +1,12 @@
+import { IkasCustomerReviewSummary } from "@ikas/storefront-models";
+
+export type IkasCustomerReviewSummaryList = {
+  data: IkasCustomerReviewSummary[];
+  limit: number;
+  page: number;
+  count: number;
+  initialized?: boolean;
+  minPage?: number | null;
+  productId: string;
+  isLoading?: boolean;
+};

package/src/models/ui/customer-review-summary-list/init.ts

@@ -0,0 +1,33 @@
+import { listCustomerReviewSummary } from "@ikas/storefront-api";
+import { IkasCustomerReviewSummaryList } from ".";
+
+export async function getInitial(list: IkasCustomerReviewSummaryList) {
+  try {
+    const response = await _listCustomerReviewSummary(
+      list,
+      list.page,
+      list.limit
+    );
+
+    list.data = response.data?.data || [];
+    list.count = response.data?.count || 0;
+    list.initialized = true;
+    list.minPage = list.page;
+  } catch (err) {
+    console.error(err);
+  }
+}
+
+async function _listCustomerReviewSummary(
+  list: IkasCustomerReviewSummaryList,
+  page: number,
+  limit: number
+) {
+  return await listCustomerReviewSummary({
+    productId: { eq: list.productId },
+    pagination: {
+      page,
+      limit,
+    },
+  });
+}

package/src/models/ui/index.ts

@@ -0,0 +1,12 @@
+export * from "./blog-category-list";
+export * from "./blog-list";
+export * from "./brand-list";
+export * from "./category-list";
+export * from "./component-renderer";
+export * from "./customer-review-list";
+export * from "./customer-review-summary-list";
+export * from "./navigation-link";
+export * from "./product-attribute-detail";
+export * from "./product-attribute-list";
+export * from "./product-list";
+export * from "./raffle-list";

package/src/models/ui/navigation-link/index.ts

@@ -0,0 +1,7 @@
+export type IkasNavigationLink = {
+  href: string;
+  label: string;
+  subLinks: IkasNavigationLink[];
+  isExternal?: boolean | null;
+  itemId?: string;
+};