@ikas/storefront-api 4.0.0-alpha.10

package/src/api/customer/index.ts

@@ -0,0 +1,380 @@
+import { APIResponse } from "@ikas/fe-api-client";
+
+import { QueryParams as CustomerLoginQueryParams } from "../../__api/mutations/customerLogin";
+import { QueryParams as CustomerSocialLoginQueryParams } from "../../__api/queries/customerSocialLogin";
+import { QueryParams as RegisterCustomerQueryParams } from "../../__api/mutations/registerCustomer";
+import { QueryParams as CustomerRefreshTokenQueryParams } from "../../__api/mutations/customerRefreshToken";
+import { QueryParams as CustomerForgotPasswordQueryParams } from "../../__api/mutations/customerForgotPassword";
+import { QueryParams as CustomerRecoverPasswordQueryParams } from "../../__api/mutations/customerRecoverPassword";
+import { QueryParams as CheckCustomerEmailQueryParams } from "../../__api/queries/checkCustomerEmail";
+import { QueryParams as SaveMyCustomerQueryParams } from "../../__api/mutations/saveMyCustomer";
+import { QueryParams as GetCustomerOrdersQueryParams } from "../../__api/queries/getCustomerOrders";
+import { QueryParams as GetOrderByEmailQueryParams } from "../../__api/queries/getOrderByEmail";
+import { QueryParams as ListOrderTransactionsQueryParams } from "../../__api/queries/listOrderTransactions";
+import { QueryParams as CreateOrderRefundRequestQueryParams } from "../../__api/mutations/createOrderRefundRequest";
+import { QueryParams as CreateCustomerEmailSubscriptionQueryParams } from "../../__api/mutations/createCustomerEmailSubscription";
+import { QueryParams as GetLastViewedProductsQueryParams } from "../../__api/queries/getLastViewedProducts";
+import { QueryParams as SaveLastViewedProductsQueryParams } from "../../__api/mutations/saveLastViewedProducts";
+import { QueryParams as ListOrderRefundSettingsQueryParams } from "../../__api/queries/listOrderRefundSettings";
+import { QueryParams as SendContactFormToMerchantQueryParams } from "../../__api/mutations/sendContactFormToMerchant";
+import { QueryParams as SaveFavoriteProductQueryParams } from "../../__api/mutations/saveFavoriteProduct";
+import { QueryParams as IsFavoriteProductQueryParams } from "../../__api/queries/isFavoriteProduct";
+import { QueryParams as CreateCustomerReviewQueryParams } from "../../__api/mutations/createCustomerReview";
+import { QueryParams as ListCustomerReviewsQueryParams } from "../../__api/queries/listCustomerReviews";
+import { QueryParams as ListCustomerReviewSummaryQueryParams } from "../../__api/queries/listCustomerReviewSummary";
+
+import {
+  IkasCustomer,
+  IkasCustomerAttribute,
+  IkasCustomerReview,
+  IkasCustomerReviewSummary,
+  IkasFavoriteProduct,
+  IkasLastViewedProduct,
+  IkasOrder,
+  IkasOrderRefundSettings,
+  IkasOrderTransaction,
+  initIkasCustomerAttribute,
+  initIkasCustomerReview,
+} from "@ikas/storefront-models";
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+
+export type {
+  CustomerLoginQueryParams,
+  CustomerSocialLoginQueryParams,
+  RegisterCustomerQueryParams,
+  CustomerRefreshTokenQueryParams,
+  CustomerForgotPasswordQueryParams,
+  CustomerRecoverPasswordQueryParams,
+  CheckCustomerEmailQueryParams,
+  SaveMyCustomerQueryParams,
+  GetCustomerOrdersQueryParams,
+  GetOrderByEmailQueryParams,
+  ListOrderTransactionsQueryParams,
+  CreateOrderRefundRequestQueryParams,
+  CreateCustomerEmailSubscriptionQueryParams,
+  GetLastViewedProductsQueryParams,
+  SaveLastViewedProductsQueryParams,
+  ListOrderRefundSettingsQueryParams,
+  SendContactFormToMerchantQueryParams,
+  SaveFavoriteProductQueryParams,
+  IsFavoriteProductQueryParams,
+  CreateCustomerReviewQueryParams,
+  ListCustomerReviewsQueryParams,
+  ListCustomerReviewSummaryQueryParams,
+};
+
+export async function login(params: CustomerLoginQueryParams) {
+  const _customerLogin = (await import("../../__api/mutations/customerLogin"))
+    .default;
+  const response = await _customerLogin(params);
+  const customer: IkasCustomer | null =
+    (response.data?.customer as any) || null;
+
+  return new APIResponse(
+    response.data
+      ? {
+          ...response.data,
+          customer,
+        }
+      : null,
+    response.graphQLErrors
+  );
+}
+
+export async function socialLogin(params: CustomerSocialLoginQueryParams) {
+  const _customerSocialLogin = (
+    await import("../../__api/queries/customerSocialLogin")
+  ).default;
+  const response = await _customerSocialLogin(params);
+  const customer: IkasCustomer | null =
+    (response.data?.customer as any) || null;
+
+  return new APIResponse(
+    response.data
+      ? {
+          ...response.data,
+          customer,
+        }
+      : null,
+    response.graphQLErrors
+  );
+}
+
+export async function register(params: RegisterCustomerQueryParams) {
+  const _registerCustomer = (
+    await import("../../__api/mutations/registerCustomer")
+  ).default;
+  const response = await _registerCustomer(params);
+  const customer: IkasCustomer | null =
+    (response.data?.customer as any) || null;
+
+  return new APIResponse(
+    response.data
+      ? {
+          ...response.data,
+          customer,
+        }
+      : null,
+    response.graphQLErrors
+  );
+}
+
+export async function refreshToken(params: CustomerRefreshTokenQueryParams) {
+  const _customerRefreshToken = (
+    await import("../../__api/mutations/customerRefreshToken")
+  ).default;
+  return await _customerRefreshToken(params);
+}
+
+export async function forgotPassword(
+  params: CustomerForgotPasswordQueryParams
+) {
+  const _customerForgotPassword = (
+    await import("../../__api/mutations/customerForgotPassword")
+  ).default;
+  return await _customerForgotPassword(params);
+}
+
+export async function recoverPassword(
+  params: CustomerRecoverPasswordQueryParams
+) {
+  const _customerRecoverPassword = (
+    await import("../../__api/mutations/customerRecoverPassword")
+  ).default;
+  return await _customerRecoverPassword(params);
+}
+
+export async function checkEmail(params: CheckCustomerEmailQueryParams) {
+  const _checkCustomerEmail = (
+    await import("../../__api/queries/checkCustomerEmail")
+  ).default;
+  return await _checkCustomerEmail(params);
+}
+
+export async function getCustomer() {
+  const _getMyCustomer = (await import("../../__api/queries/getMyCustomer"))
+    .default;
+  const response = await _getMyCustomer();
+  const customer: IkasCustomer | null = (response.data as any) || null;
+
+  return new APIResponse(
+    response.data
+      ? {
+          ...response.data,
+          customer,
+        }
+      : null,
+    response.graphQLErrors
+  );
+}
+
+export async function saveCustomer(params: SaveMyCustomerQueryParams) {
+  const _saveMyCustomer = (await import("../../__api/mutations/saveMyCustomer"))
+    .default;
+  const response = await _saveMyCustomer(params);
+  const customer: IkasCustomer | null = (response.data as any) || null;
+
+  return new APIResponse(
+    response.data
+      ? {
+          ...response.data,
+          customer,
+        }
+      : null,
+    response.graphQLErrors
+  );
+}
+
+export async function getOrders(params: GetCustomerOrdersQueryParams) {
+  const _getCustomerOrders = (
+    await import("../../__api/queries/getCustomerOrders")
+  ).default;
+  const response = await _getCustomerOrders(params);
+  const data: IkasOrder[] | undefined = response.data as any;
+
+  return new APIResponse(data, response.graphQLErrors);
+}
+
+export async function getOrderByEmail(params: GetOrderByEmailQueryParams) {
+  const _getOrderByEmail = (await import("../../__api/queries/getOrderByEmail"))
+    .default;
+  const response = await _getOrderByEmail(params);
+  const data: IkasOrder | undefined = response.data as any;
+
+  return new APIResponse(data, response.graphQLErrors);
+}
+
+export async function listOrderTransactions(
+  params: ListOrderTransactionsQueryParams
+) {
+  const _listOrderTransactions = (
+    await import("../../__api/queries/listOrderTransactions")
+  ).default;
+  const response = await _listOrderTransactions(params);
+  const data: IkasOrderTransaction[] | undefined = response.data as any;
+
+  return new APIResponse(data, response.graphQLErrors);
+}
+
+export async function createOrderRefundRequest(
+  params: CreateOrderRefundRequestQueryParams
+) {
+  const _createOrderRefundRequest = (
+    await import("../../__api/mutations/createOrderRefundRequest")
+  ).default;
+  const response = await _createOrderRefundRequest(params);
+  const data: IkasOrder | null = response.data as any;
+
+  return new APIResponse(data, response.graphQLErrors);
+}
+
+export async function createCustomerEmailSubscription(
+  params: CreateCustomerEmailSubscriptionQueryParams
+) {
+  const _createCustomerEmailSubscription = (
+    await import("../../__api/mutations/createCustomerEmailSubscription")
+  ).default;
+  return await _createCustomerEmailSubscription(params);
+}
+
+export async function getLastViewedProducts(
+  params: GetLastViewedProductsQueryParams
+) {
+  const _getLastViewedProducts = (
+    await import("../../__api/queries/getLastViewedProducts")
+  ).default;
+  const response = await _getLastViewedProducts(params);
+  return new APIResponse(
+    response.data?.products as IkasLastViewedProduct[] | undefined,
+    response.graphQLErrors
+  );
+}
+
+export async function saveLastViewedProducts(
+  params: SaveLastViewedProductsQueryParams
+) {
+  const _saveLastViewedProducts = (
+    await import("../../__api/mutations/saveLastViewedProducts")
+  ).default;
+  return await _saveLastViewedProducts(params);
+}
+
+export async function listOrderRefundSettings(
+  params: ListOrderRefundSettingsQueryParams
+) {
+  const _listOrderRefundSettings = (
+    await import("../../__api/queries/listOrderRefundSettings")
+  ).default;
+  const response = await _listOrderRefundSettings(params);
+  const data: IkasOrderRefundSettings[] | null =
+    response.data?.map((d) => ({
+      ...d,
+    })) || null;
+
+  return new APIResponse(data, response.graphQLErrors);
+}
+
+export async function sendContactFormToMerchant(
+  params: SendContactFormToMerchantQueryParams
+) {
+  const _sendContactFormToMerchant = (
+    await import("../../__api/mutations/sendContactFormToMerchant")
+  ).default;
+  return await _sendContactFormToMerchant(params);
+}
+
+export async function listFavoriteProducts() {
+  const _listFavoriteProducts = (
+    await import("../../__api/queries/listFavoriteProducts")
+  ).default;
+  const response = await _listFavoriteProducts();
+  const products: IkasFavoriteProduct[] | null = response.data || null;
+
+  return new APIResponse(products, response.graphQLErrors);
+}
+
+export async function saveFavoriteProduct(
+  params: SaveFavoriteProductQueryParams
+) {
+  const _saveFavoriteProduct = (
+    await import("../../__api/mutations/saveFavoriteProduct")
+  ).default;
+  return await _saveFavoriteProduct(params);
+}
+
+export async function isFavoriteProduct(params: IsFavoriteProductQueryParams) {
+  const _isFavoriteProduct = (
+    await import("../../__api/queries/isFavoriteProduct")
+  ).default;
+  return await _isFavoriteProduct({
+    productId: params.productId,
+  });
+}
+
+export async function createCustomerReview(
+  params: CreateCustomerReviewQueryParams
+) {
+  const _createCustomerReview = (
+    await import("../../__api/mutations/createCustomerReview")
+  ).default;
+  const response = await _createCustomerReview(params);
+  const data: IkasCustomerReview | undefined = response.data as any;
+
+  data && initIkasCustomerReview(data);
+
+  return new APIResponse(data, response.graphQLErrors);
+}
+
+export async function listCustomerReviews(
+  params: ListCustomerReviewsQueryParams
+) {
+  const _listCustomerReviews = (
+    await import("../../__api/queries/listCustomerReviews")
+  ).default;
+  const response = await _listCustomerReviews(params);
+  const data: IkasCustomerReview[] = (response.data?.data as any) || [];
+
+  data.forEach(initIkasCustomerReview);
+
+  return new APIResponse(
+    response.data
+      ? {
+          ...response.data,
+          data,
+        }
+      : null,
+    response.graphQLErrors
+  );
+}
+
+export async function listCustomerReviewSummary(
+  params: ListCustomerReviewSummaryQueryParams
+) {
+  const _listCustomerReviewSummary = (
+    await import("../../__api/queries/listCustomerReviewSummary")
+  ).default;
+  const response = await _listCustomerReviewSummary(params);
+  const data: IkasCustomerReviewSummary[] = response.data?.data || [];
+
+  return new APIResponse(
+    {
+      ...response.data,
+      data,
+    },
+    response.graphQLErrors
+  );
+}
+
+export async function listCustomerAttribute() {
+  const _listCustomerAttribute = (
+    await import("../../__api/queries/listCustomerAttribute")
+  ).default;
+  const response = await _listCustomerAttribute();
+  const data: IkasCustomerAttribute[] = (response.data as any) || [];
+
+  data.forEach((a) =>
+    initIkasCustomerAttribute(a, IkasStorefrontConfig.getCurrentLocale())
+  );
+
+  return new APIResponse(data, response.graphQLErrors);
+}

package/src/api/file-upload/index.ts

@@ -0,0 +1,38 @@
+import { IkasProductOption } from "@ikas/storefront-models";
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+
+export async function uploadProductOptionFile(
+  file: File,
+  option: IkasProductOption
+) {
+  const URL = `${IkasStorefrontConfig.getAdminApiUrl()}/upload-product-option-file`;
+  const response = await fetch(URL, {
+    method: "POST",
+    headers: {
+      "x-api-key": IkasStorefrontConfig.getApiKey() || "",
+      "x-sfid": IkasStorefrontConfig.getStorefrontId() || "",
+      "x-sfrid": IkasStorefrontConfig.getStorefrontRoutingId() || "",
+      "Content-Type": "application/json",
+      Accept: "application/json",
+    },
+    body: JSON.stringify({
+      base64: await getBase64(file),
+      fileName: file.name,
+      productOptionSetId: option.productOptionSetId,
+      productOptionId: option.id,
+    }),
+  });
+
+  if (!response.ok) {
+    return null;
+  }
+  return await response.text();
+}
+
+export function getBase64(file: File): Promise<string | null> {
+  return new Promise((resolve) => {
+    const reader = new FileReader();
+    reader.addEventListener("load", () => resolve(reader.result as string));
+    reader.readAsDataURL(file);
+  });
+}

package/src/api/html-meta-data/index.ts

@@ -0,0 +1,25 @@
+import { APIResponse } from "@ikas/fe-api-client";
+
+import { QueryParams as ListHTMLMetaDataQueryParams } from "../../__api/queries/listHTMLMetaData";
+
+import {
+  IkasHTMLMetaData,
+  initIkasHTMLMetaData,
+} from "@ikas/storefront-models";
+import { IkasStorefrontConfig } from "@ikas/storefront-config";
+
+export type { ListHTMLMetaDataQueryParams };
+
+export async function listHTMLMetaData(params: ListHTMLMetaDataQueryParams) {
+  const _listHTMLMetaData = (
+    await import("../../__api/queries/listHTMLMetaData")
+  ).default;
+  const response = await _listHTMLMetaData(params);
+  const data: IkasHTMLMetaData[] = (response.data as any) || [];
+
+  data.forEach((h) =>
+    initIkasHTMLMetaData(h, IkasStorefrontConfig.getCurrentLocale())
+  );
+
+  return new APIResponse(data, response.graphQLErrors);
+}

package/src/api/location/index.ts

@@ -0,0 +1,64 @@
+import { APIResponse } from "@ikas/fe-api-client";
+
+import { QueryParams as ListCountryQueryParams } from "../../__api/queries/listCountry";
+import { QueryParams as ListCityQueryParams } from "../../__api/queries/listCity";
+import { QueryParams as ListDistrictQueryParams } from "../../__api/queries/listDistrict";
+import { QueryParams as ListStateQueryParams } from "../../__api/queries/listState";
+
+import {
+  IkasCity,
+  IkasCountry,
+  IkasDistrict,
+  IkasState,
+} from "@ikas/storefront-models";
+
+export type {
+  ListCountryQueryParams,
+  ListCityQueryParams,
+  ListDistrictQueryParams,
+  ListStateQueryParams,
+};
+
+export async function getMyCountry() {
+  const _getMyCountry = (await import("../../__api/queries/getMyCountry"))
+    .default;
+  return await _getMyCountry();
+}
+
+export async function listCountry(params: ListCountryQueryParams) {
+  const _listCountry = (await import("../../__api/queries/listCountry"))
+    .default;
+  const response = await _listCountry(params);
+  return new APIResponse(
+    response.data as IkasCountry[] | undefined,
+    response.graphQLErrors
+  );
+}
+
+export async function listCity(params: ListCityQueryParams) {
+  const _listCity = (await import("../../__api/queries/listCity")).default;
+  const response = await _listCity(params);
+  return new APIResponse(
+    response.data as IkasCity[] | undefined,
+    response.graphQLErrors
+  );
+}
+
+export async function listDistrict(params: ListDistrictQueryParams) {
+  const _listDistrict = (await import("../../__api/queries/listDistrict"))
+    .default;
+  const response = await _listDistrict(params);
+  return new APIResponse(
+    response.data as IkasDistrict[] | undefined,
+    response.graphQLErrors
+  );
+}
+
+export async function listState(params: ListStateQueryParams) {
+  const _listState = (await import("../../__api/queries/listState")).default;
+  const response = await _listState(params);
+  return new APIResponse(
+    response.data as IkasState[] | undefined,
+    response.graphQLErrors
+  );
+}

package/src/api/masterpass/index.ts

@@ -0,0 +1,12 @@
+import { QueryParams as GetMasterpassRequestTokenQueryParams } from "../../__api/queries/getMasterpassRequestToken";
+
+export type { GetMasterpassRequestTokenQueryParams };
+
+export async function getMasterpassRequestToken(
+  data: GetMasterpassRequestTokenQueryParams
+) {
+  const _getMasterpassRequestToken = (
+    await import("../../__api/queries/getMasterpassRequestToken")
+  ).default;
+  return await _getMasterpassRequestToken(data);
+}

package/src/api/merchant/index.ts

@@ -0,0 +1,24 @@
+import { APIResponse } from "@ikas/fe-api-client";
+
+import { QueryParams as ListMerchantSettingsQueryParams } from "../../__api/queries/listMerchantSettings";
+
+import {
+  IkasMerchantSettings,
+  initIkasMerchantSettings,
+} from "@ikas/storefront-models";
+
+export type { ListMerchantSettingsQueryParams };
+
+export async function listMerchantSettings(
+  params: ListMerchantSettingsQueryParams
+) {
+  const _listMerchantSettings = (
+    await import("../../__api/queries/listMerchantSettings")
+  ).default;
+  const response = await _listMerchantSettings(params);
+  const data: IkasMerchantSettings[] | null = response.data as any;
+
+  data?.forEach(initIkasMerchantSettings);
+
+  return new APIResponse(data?.length ? data[0] : null, response.graphQLErrors);
+}