@ikas/storefront-models 4.0.0-alpha.86 → 4.0.0-alpha.9

package/src/models/payment-gateway/settings/index.ts

@@ -0,0 +1,12 @@
+export type IkasPaymentGatewaySettings = {
+  label: string;
+  order: number;
+  type: IkasPaymentGatewaySettingsType;
+  value: string | null;
+};
+
+export enum IkasPaymentGatewaySettingsType {
+  NUMBER = "NUMBER",
+  PASSWORD = "PASSWORD",
+  TEXT = "TEXT",
+}

package/src/models/payment-gateway/translation/index.ts

@@ -0,0 +1,5 @@
+export type IkasPaymentGatewayTranslation = {
+  description: string | null;
+  locale: string | null;
+  name: string | null;
+};

package/src/models/product/attribute/index.ts

@@ -0,0 +1,24 @@
+import { IkasProductAttributeTableTemplate } from "./table-template";
+import { IkasProductAttributeOption } from "./option";
+import { IkasProductAttributeTranslation } from "./translation";
+
+export type IkasProductAttribute = {
+  id: string;
+  name: string;
+  description: string | null;
+  type: IkasProductAttributeType;
+  options: IkasProductAttributeOption[] | null;
+  tableTemplate: IkasProductAttributeTableTemplate | null;
+  translations?: IkasProductAttributeTranslation[] | null;
+};
+
+export enum IkasProductAttributeType {
+  CHOICE = "CHOICE",
+  MULTIPLE_CHOICE = "MULTIPLE_CHOICE",
+  TEXT = "TEXT",
+  BOOLEAN = "BOOLEAN",
+  NUMERIC = "NUMERIC",
+  DATETIME = "DATETIME",
+  HTML = "HTML",
+  TABLE = "TABLE",
+}

package/src/models/product/attribute/init.ts

@@ -0,0 +1,34 @@
+import { IkasProductAttribute } from ".";
+import { IkasProductAttributeTranslation } from "./translation";
+
+export function initIkasProductAttribute(
+  attribute: IkasProductAttribute,
+  locale: string | null
+) {
+  if (attribute.translations && locale) {
+    setTranslations(attribute, attribute.translations, locale);
+    delete attribute.translations;
+  }
+}
+
+function setTranslations(
+  attribute: IkasProductAttribute,
+  translations: IkasProductAttributeTranslation[],
+  locale: string
+) {
+  if (translations && translations.some((t) => t.locale === locale)) {
+    const localeTranslations = translations.find((t) => t.locale === locale);
+
+    if (localeTranslations?.name) attribute.name = localeTranslations.name;
+    if (localeTranslations?.description)
+      attribute.description = localeTranslations.description;
+    if (localeTranslations?.options) {
+      attribute.options?.forEach((o) => {
+        const translatedVV = localeTranslations.options?.find(
+          (to) => to.id === o.id
+        );
+        if (translatedVV && translatedVV.name) o.name = translatedVV.name;
+      });
+    }
+  }
+}

package/src/models/product/attribute/option/index.ts

@@ -0,0 +1,4 @@
+export type IkasProductAttributeOption = {
+  id: string;
+  name: string;
+};

package/src/models/product/attribute/table-cell/index.ts

@@ -0,0 +1,4 @@
+export type IkasProductAttributeTableCell = {
+  id: string;
+  name: string | null;
+};

package/src/models/product/attribute/table-template/index.ts

@@ -0,0 +1,6 @@
+import { IkasProductAttributeTableCell } from "../table-cell";
+
+export type IkasProductAttributeTableTemplate = {
+  columns: IkasProductAttributeTableCell[] | null;
+  rows: IkasProductAttributeTableCell[] | null;
+};

package/src/models/product/attribute/translation/index.ts

@@ -0,0 +1,11 @@
+export type IkasProductAttributeTranslation = {
+  description: string | null;
+  locale: string;
+  name: string | null;
+  options: IkasProductAttributeOptionTranslation[] | null;
+};
+
+export type IkasProductAttributeOptionTranslation = {
+  id: string;
+  name: string | null;
+};

package/src/models/product/attribute-value/index.ts

@@ -0,0 +1,26 @@
+import { IkasImage } from "../../image";
+import { IkasProductAttribute } from "../attribute";
+import { IkasProductAttributeOption } from "../attribute/option";
+
+export type IkasProductAttributeValue = {
+  imageIds: string[] | null;
+  productAttributeId: string | null;
+  productAttributeOptionId: string | null;
+  value: string | null;
+
+  // Extra
+  images?: IkasImage[];
+  productAttribute?: IkasProductAttribute | null;
+  productAttributeOption?: IkasProductAttributeOption | null;
+};
+
+export type IkasAttributeTableCellValue = {
+  colId: string;
+  rowId: string;
+  value: string | null;
+};
+
+export type IkasProductAttributeMap = {
+  attribute: IkasProductAttribute;
+  values: IkasProductAttributeValue[];
+};

package/src/models/product/attribute-value/init.ts

@@ -0,0 +1,7 @@
+import { IkasProductAttributeValue } from ".";
+
+export function initIkasProductAttributeValue(
+  value: IkasProductAttributeValue
+) {
+  value.images = value.imageIds?.map((i) => ({ id: i, isVideo: false }));
+}

package/src/models/product/back-in-stock-settings/index.ts

@@ -0,0 +1,3 @@
+export type IkasProductBackInStockSettings = {
+  customerLoginRequired: boolean;
+};

package/src/models/product/campaign/data/index.ts

@@ -0,0 +1,43 @@
+import { IkasProductBuyXThenGetY } from "../product-buyx-then-gety";
+import { IkasProductCampaignDateRangeField } from "../product-campaign-date-range-field";
+import { IkasProductFixedDiscount } from "../product-fixed-discount";
+
+export type IkasProductCampaignData = {
+  applicableCustomerGroupIds: string[] | null;
+  applicableCustomerIds: string[] | null;
+  applicablePrice: IkasCampaignApplicablePrice;
+  buyXThenGetY: IkasProductBuyXThenGetY;
+  canCombineWithOtherCampaigns: boolean;
+  createdFor: IkasCampaignCreatedFor | null;
+  currencyCodes: [string] | null;
+  dateRange: IkasProductCampaignDateRangeField | null;
+  deleted: boolean;
+  fixedDiscount: IkasProductFixedDiscount | null;
+  hasCoupon: boolean;
+  id: string;
+  includeDiscountedProducts: boolean | null;
+  salesChannelIds: string[] | null;
+  title: string;
+  type: IkasCampaignType;
+  usageCount: number;
+  usageLimit: number | null;
+  usageLimitPerCustomer: number | null;
+};
+
+export enum IkasCampaignApplicablePrice {
+  DISCOUNT_PRICE = "DISCOUNT_PRICE",
+  SELL_PRICE = "SELL_PRICE",
+}
+
+export enum IkasCampaignCreatedFor {
+  ABANDONED_CHECKOUT = "ABANDONED_CHECKOUT",
+  CART = "CART",
+  CUSTOMER_REVIEW = "CUSTOMER_REVIEW",
+}
+
+export enum IkasCampaignType {
+  BUY_X_THEN_GET_Y = "BUY_X_THEN_GET_Y",
+  FIXED_AMOUNT = "FIXED_AMOUNT",
+  FREE_SHIPPING = "FREE_SHIPPING",
+  RATIO = "FREE_SHIPPING",
+}

package/src/models/product/campaign/filter/index.ts

@@ -0,0 +1,12 @@
+export type IkasProductCampaignFilter = {
+  idList: string[];
+  type: IkasCampaignFilterType;
+};
+
+export enum IkasCampaignFilterType {
+  CATEGORY = "CATEGORY",
+  PRODUCT = "PRODUCT",
+  PRODUCT_BRAND = "PRODUCT_BRAND",
+  PRODUCT_TAG = "PRODUCT_TAG",
+  VARIANT = "VARIANT",
+}

package/src/models/product/campaign/index.ts

@@ -0,0 +1,6 @@
+import { IkasProductCampaignData } from "./data";
+
+export type IkasProductCampaign = {
+  campaign: IkasProductCampaignData;
+  variantIds: string[];
+};

package/src/models/product/campaign/product-buyx-then-gety/index.ts

@@ -0,0 +1,19 @@
+import { IkasProductCampaignFilter } from "../filter";
+
+export type IkasProductBuyX = {
+  amount: number;
+  applyByQuantity: boolean;
+  filter: IkasProductCampaignFilter;
+};
+
+export type IkasProductGetY = {
+  amount: number;
+  discountRatio: number;
+  filter: IkasProductCampaignFilter;
+};
+
+export type IkasProductBuyXThenGetY = {
+  buyX: IkasProductBuyX;
+  getY: IkasProductGetY;
+  maxUsagePerOrder: number;
+};

package/src/models/product/campaign/product-campaign-date-range-field/index.ts

@@ -0,0 +1,4 @@
+export type IkasProductCampaignDateRangeField = {
+  start: number | null;
+  end: number | null;
+};

package/src/models/product/campaign/product-fixed-discount/index.ts

@@ -0,0 +1,13 @@
+import { IkasProductCampaignFilter } from "../filter";
+
+export type IkasCampaignMinMaxRangeField = {
+  min: number | null;
+  max: number | null;
+};
+
+export type IkasProductFixedDiscount = {
+  amount: number | null;
+  filters: IkasProductCampaignFilter | null;
+  lineItemQuantityRange: IkasCampaignMinMaxRangeField | null;
+  priceRange: IkasCampaignMinMaxRangeField | null;
+};

package/src/models/product/filter/index.ts

@@ -0,0 +1,96 @@
+import { IkasImage } from "../../image";
+
+export type IkasProductFilter = {
+  id: string;
+  key: string;
+  name: string;
+  order: number;
+  type: IkasProductFilterType;
+  displayType: IkasProductFilterDisplayType;
+  isMultiSelect: boolean;
+  isFacetFilter: boolean | null;
+  values?: IkasApplicableProductFilterValue[] | null;
+  customValues?: string[] | null;
+  settings?: IkasProductFilterSettings | null;
+
+  // Extra
+  numberRange?: IkasFilterRangeValue | null; // Selected range value for the number slider
+  numberRangeLimit?: IkasFilterRangeValue | null; // Limits for the number range slider
+  numberRangeListOptions?: IkasProductFilterNumberRangeListOption[] | null; // List options for the number range select
+};
+
+export type IkasApplicableProductFilterValue = {
+  id: string;
+  key: string;
+  name: string;
+  colorCode?: string | null;
+  thumbnailImageId?: string | null;
+  thumbnailImage?: IkasImage | null;
+  resultCount?: number | null;
+
+  // Extra
+  isSelected: boolean;
+};
+
+export type IkasProductFilterValue = {
+  id: string;
+  type: IkasProductFilterType;
+  displayType: IkasProductFilterDisplayType;
+  valueList: string[];
+};
+
+export type IkasProductFilterSettings = {
+  useAndFilter?: boolean | null;
+  showCollapsedOnDesktop: boolean;
+  showCollapsedOnMobile: boolean;
+  sortType: IkasProductFilterSortType;
+};
+
+export type IkasProductFacetInput = {
+  id: string;
+  type: IkasProductFilterType;
+  displayType: IkasProductFilterDisplayType;
+};
+
+export enum IkasProductFilterType {
+  ATTRIBUTE = "ATTRIBUTE",
+  BRAND = "BRAND",
+  DISCOUNT_RATIO = "DISCOUNT_RATIO",
+  PRICE = "PRICE",
+  STOCK_STATUS = "STOCK_STATUS",
+  TAG = "TAG",
+  VARIANT_TYPE = "VARIANT_TYPE",
+}
+
+export enum IkasProductFilterDisplayType {
+  BOX = "BOX",
+  DATE_RANGE = "DATE_RANGE",
+  LIST = "LIST",
+  NUMBER_RANGE_LIST = "NUMBER_RANGE_LIST",
+  NUMBER_RANGE = "NUMBER_RANGE",
+  SWATCH = "SWATCH",
+}
+
+export enum IkasProductFilterSortType {
+  ALPHABETICAL_ASC = "ALPHABETICAL_ASC",
+  ALPHABETICAL_DESC = "ALPHABETICAL_DESC",
+  PRODUCT_COUNT_ASC = "PRODUCT_COUNT_ASC",
+  PRODUCT_COUNT_DESC = "PRODUCT_COUNT_DESC",
+}
+
+export enum IkasProductStockFilterValue {
+  IN_STOCK = "in-stock",
+  OUT_OF_STOCK = "out-of-stock",
+}
+
+export type IkasFilterRangeValue = {
+  from: number;
+  to: number | undefined | null;
+};
+
+export type IkasProductFilterNumberRangeListOption = {
+  from: number;
+  to: number | undefined | null;
+  key: string;
+  isSelected: boolean;
+};

package/src/models/product/image/index.ts

@@ -0,0 +1,10 @@
+import { IkasImage } from "../../image";
+
+export type IkasProductImage = {
+  imageId: string | null;
+  isMain: boolean;
+  isVideo: boolean | null;
+  order: number;
+
+  image?: IkasImage | null;
+};

package/src/models/product/image/init.ts

@@ -0,0 +1,7 @@
+import { IkasProductImage } from ".";
+
+export function initIkasProductImage(productImage: IkasProductImage) {
+  productImage.image = productImage.imageId
+    ? { id: productImage.imageId, isVideo: productImage.isVideo || false }
+    : null;
+}

package/src/models/product/index.ts

@@ -0,0 +1,43 @@
+import { IkasCategory } from "../category";
+import { IkasProductVariant } from "./variant";
+import { IkasProductAttributeValue } from "./attribute-value";
+import { IkasProductVariantType } from "./variant-type";
+import { IkasBrand } from "../brand";
+import { IkasHTMLMetaData } from "../html-meta-data";
+import { IkasProductTag } from "./tag";
+import { IkasVariantValue } from "../variant-type/variant-value";
+import { IkasVariantType } from "../variant-type";
+
+export type IkasProduct = {
+  id: string;
+  name: string;
+  type: IkasProductType;
+  description: string;
+  shortDescription: string;
+  metaData: IkasHTMLMetaData | null;
+  brand: IkasBrand | null;
+  categories: IkasCategory[];
+  tags: IkasProductTag[] | null;
+  variants: IkasProductVariant[];
+  attributes: IkasProductAttributeValue[];
+  variantTypes: IkasProductVariantType[];
+  productOptionSetId: string | null;
+};
+
+export enum IkasProductType {
+  PHYSICAL = "PHYSICAL",
+  DIGITAL = "DIGITAL",
+  MEMBERSHIP = "MEMBERSHIP",
+}
+
+export type IkasDisplayedVariantValue = {
+  variant: IkasProductVariant; // TODO remove?
+  variantValue: IkasVariantValue;
+  hasStock: boolean;
+  isSelected: boolean;
+};
+
+export type IkasDisplayedVariantType = {
+  variantType: IkasVariantType;
+  displayedVariantValues: IkasDisplayedVariantValue[];
+};

package/src/models/product/init.ts

@@ -0,0 +1,16 @@
+import type { IkasProduct } from ".";
+import { initIkasProductVariantType } from "./variant-type/init";
+import { initIkasProductVariant } from "./variant/init";
+import { initIkasProductAttributeValue } from "./attribute-value/init";
+import { initIkasBrand } from "../brand/init";
+import { initIkasCategory } from "../category/init";
+import { initIkasHTMLMetaData } from "../html-meta-data/init";
+
+export function initIkasProduct(product: IkasProduct, locale: string | null) {
+  product.metaData && initIkasHTMLMetaData(product.metaData, locale);
+  product.brand && initIkasBrand(product.brand, locale);
+  product.categories.forEach((c) => initIkasCategory(c, locale));
+  product.variants.forEach(initIkasProductVariant);
+  product.attributes.forEach(initIkasProductAttributeValue);
+  product.variantTypes.forEach(initIkasProductVariantType);
+}

package/src/models/product/option-set/index.ts

@@ -0,0 +1,25 @@
+import { IkasProductOption } from "./option";
+
+export type IkasProductOptionSelectValueTranslations = {
+  id: string;
+  value: string | null;
+};
+
+export type IkasProductOptionTranslations = {
+  id: string;
+  name: string | null;
+  optionalText: string | null;
+  values: IkasProductOptionSelectValueTranslations[] | null;
+};
+
+export type IkasProductOptionSetTranslations = {
+  locale: string;
+  options: IkasProductOptionTranslations[] | null;
+};
+
+export type IkasProductOptionSet = {
+  id: string;
+  name: string;
+  options: IkasProductOption[];
+  translations?: IkasProductOptionSetTranslations[] | null;
+};

package/src/models/product/option-set/init.ts

@@ -0,0 +1,77 @@
+import { IkasProductOptionSet, IkasProductOptionSetTranslations } from ".";
+import { IkasProductOption, IkasProductOptionType } from "./option";
+import { initIkasProductOption } from "./option/init";
+
+export function initIkasProductOptionSet(
+  optionSet: IkasProductOptionSet,
+  locale: string | null
+) {
+  optionSet.options.forEach((option) => {
+    option.productOptionSetId = optionSet.id;
+    initIkasProductOption(option);
+  });
+
+  if (optionSet.translations && locale) {
+    setTranslations(optionSet, optionSet.translations, locale);
+    delete optionSet.translations;
+  }
+  setChildOptions(optionSet);
+  initOptionValues(optionSet);
+}
+
+function setTranslations(
+  optionSet: IkasProductOptionSet,
+  translations: IkasProductOptionSetTranslations[],
+  locale: string
+) {
+  if (translations && translations.some((t) => t.locale === locale)) {
+    const localeTranslations = translations.find((t) => t.locale === locale);
+
+    localeTranslations?.options?.forEach((translatedOption) => {
+      const option = optionSet.options.find(
+        (o) => o.id === translatedOption.id
+      );
+
+      if (option) {
+        option.name = translatedOption.name || option.name;
+        option.optionalText =
+          translatedOption.optionalText || option.optionalText;
+
+        if (option.type === IkasProductOptionType.CHOICE) {
+          translatedOption.values?.forEach((translatedValue) => {
+            const selectValue = option.selectSettings?.values.find(
+              (sv) => sv.id === translatedValue.id
+            );
+            if (selectValue) {
+              selectValue.value = translatedValue.value || selectValue.value;
+            }
+          });
+        }
+      }
+    });
+  }
+}
+
+export function setChildOptions(optionSet: IkasProductOptionSet) {
+  optionSet.options.forEach((option) => {
+    const childOptions = optionSet.options.filter(
+      (o) => o.requiredOptionId === option.id
+    );
+    if (childOptions.length) {
+      option.childOptions = childOptions;
+    }
+  });
+}
+
+export function initOptionValues(optionSet: IkasProductOptionSet) {
+  optionSet.options.forEach((o) => initValues(o));
+}
+
+export function initValues(option: IkasProductOption) {
+  if (!option.isOptional) {
+    option.values = [];
+    if (option.childOptions) {
+      option.childOptions.forEach((co) => initValues(co));
+    }
+  }
+}

package/src/models/product/option-set/option/index.ts

@@ -0,0 +1,81 @@
+import { IkasImage } from "../../../image";
+
+export enum IkasProductOptionSelectType {
+  BOX = "BOX",
+  SELECT = "SELECT",
+  SWATCH = "SWATCH",
+}
+
+export enum IkasProductOptionType {
+  CHECKBOX = "CHECKBOX",
+  CHOICE = "CHOICE",
+  COLOR_PICKER = "COLOR_PICKER",
+  DATE_PICKER = "DATE_PICKER",
+  FILE = "FILE",
+  IMAGE = "IMAGE",
+  TEXT = "TEXT",
+  TEXT_AREA = "TEXT_AREA",
+}
+
+export type IkasProductOptionOtherPrice = {
+  currencyCode: string;
+  price: number;
+};
+
+export type IkasProductOptionSelectValue = {
+  id: string;
+  order: number;
+  value: string;
+  price: number | null;
+  otherPrices: IkasProductOptionOtherPrice[] | null;
+  thumbnailImageId: string | null;
+  colorCode: string | null;
+  thumbnailImage: IkasImage | null;
+};
+
+export type IkasProductOptionSelectSettings = {
+  type: IkasProductOptionSelectType;
+  minSelect: number | null;
+  maxSelect: number | null;
+  values: IkasProductOptionSelectValue[];
+};
+
+export type IkasProductOptionDateSettings = {
+  min: Date | null;
+  max: Date | null;
+  minRelativeNextDate: number | null;
+  maxRelativeNextDate: number | null;
+};
+
+export type IkasProductOptionTextSettings = {
+  min: number | null;
+  max: number | null;
+};
+
+export type IkasProductOptionFileSettings = {
+  allowedExtensions: string[] | null;
+  minQuantity: number | null;
+  maxQuantity: number | null;
+};
+
+export type IkasProductOption = {
+  id: string;
+  productOptionSetId: string;
+  name: string;
+  order: number;
+  type: IkasProductOptionType;
+  selectSettings: IkasProductOptionSelectSettings | null;
+  textSettings: IkasProductOptionTextSettings | null;
+  fileSettings: IkasProductOptionFileSettings | null;
+  dateSettings: IkasProductOptionDateSettings | null;
+  price: number | null;
+  otherPrices: IkasProductOptionOtherPrice[] | null;
+  isOptional: boolean;
+  optionalText: string | null;
+  requiredOptionId: string | null;
+  requiredOptionValueIds: string[] | null;
+
+  // Extra
+  values: string[];
+  childOptions: IkasProductOption[];
+};

package/src/models/product/option-set/option/init.ts

@@ -0,0 +1,13 @@
+import { IkasProductOption, IkasProductOptionSelectSettings } from ".";
+import _sortBy from "lodash/sortBy";
+
+export function initIkasProductOption(option: IkasProductOption) {
+  if (option.selectSettings)
+    initProductOptionSelectSettings(option.selectSettings);
+}
+
+function initProductOptionSelectSettings(
+  settings: IkasProductOptionSelectSettings
+) {
+  settings.values = _sortBy(settings.values || [], "order");
+}

package/src/models/product/tag/index.ts

@@ -0,0 +1,4 @@
+export type IkasProductTag = {
+  id: string;
+  name: string;
+};

package/src/models/product/variant/index.ts

@@ -0,0 +1,20 @@
+import { IkasProductPrice } from "./price";
+import { IkasVariantValue } from "../../variant-type/variant-value";
+import { IkasProductAttributeValue } from "../attribute-value";
+import { IkasProductCampaign } from "../campaign";
+import { IkasProductImage } from "../image";
+
+export type IkasProductVariant = {
+  id: string;
+  sku: string | null;
+  barcodeList: string[] | null;
+  variantValues: IkasVariantValue[];
+  attributes: IkasProductAttributeValue[];
+  price: IkasProductPrice;
+  stock: number;
+  isActive: boolean;
+  productId: string;
+  sellIfOutOfStock: boolean;
+  images: IkasProductImage[] | null;
+  campaigns?: IkasProductCampaign[];
+};

package/src/models/product/variant/init.ts

@@ -0,0 +1,10 @@
+import { initIkasProductImage } from "../image/init";
+import { initIkasProductAttributeValue } from "../attribute-value/init";
+import _sortBy from "lodash/sortBy";
+import { IkasProductVariant } from ".";
+
+export function initIkasProductVariant(variant: IkasProductVariant) {
+  variant.images?.forEach(initIkasProductImage);
+  variant.images = _sortBy(variant.images, "order");
+  variant.attributes.forEach(initIkasProductAttributeValue);
+}