@scayle/storefront-core 7.22.1

package/dist/rpc/methods/session.mjs

@@ -0,0 +1,309 @@
+import axios from "axios";
+import { decodeJwt } from "jose";
+import { DEFAULT_WITH_LISTING, HttpStatusCode } from "../../constants/index.mjs";
+import { convertErrorForRpcCall } from "../../utils/rpc.mjs";
+import { encodeBase64 } from "../../utils/hash.mjs";
+import { mergeBaskets, mergeWishlists } from "../../utils/user.mjs";
+import { fetchUser } from "../../rpc/methods/user.mjs";
+class MissingCredentialsError extends Error {
+  constructor() {
+    super("[Token based Authentication] No credentials configured");
+    this.name = "MissingCredentialsError";
+  }
+}
+function getOAuthSettings(context) {
+  const clientId = context.oauth?.clientId ?? process.env.OAUTH_CLIENT_ID;
+  const clientSecret = context.oauth?.clientSecret ?? process.env.OAUTH_CLIENT_SECRET;
+  const apiHost = context.oauth?.apiHost ?? process.env.OAUTH_API_HOST;
+  if (!clientId || !clientSecret) {
+    throw new MissingCredentialsError();
+  }
+  const BASIC_AUTH_HASH = encodeBase64(`${clientId}:${clientSecret}`);
+  const axiosInstance2 = axios.create({
+    baseURL: `${apiHost}/v1`,
+    headers: {
+      Authorization: `Basic ${BASIC_AUTH_HASH}`
+    }
+  });
+  return {
+    clientId,
+    clientSecret,
+    apiHost,
+    axiosInstance: axiosInstance2
+  };
+}
+const saveUserOnSession = async (accessToken, context) => {
+  const checkoutUrl = context.checkout.url;
+  const shopId = context.shopId;
+  const user = await fetchUser(
+    { accessToken, callback: "" },
+    {
+      checkoutUrl,
+      shopId
+    }
+  );
+  context.updateUser(user);
+};
+export const oauthLogin = async (login, context) => {
+  const shopId = context.shopId;
+  const { axiosInstance: axiosInstance2 } = getOAuthSettings(context);
+  if (!login.email || !login.password) {
+    throw new Error(
+      "Login or password are missing, seems like validation has failed"
+    );
+  }
+  try {
+    const response = await axiosInstance2.post(
+      "/auth/login",
+      {
+        ...login,
+        shop_id: shopId
+      }
+    );
+    context.updateTokens({
+      accessToken: response.data.access_token,
+      refreshToken: response.data.refresh_token
+    });
+    await saveUserOnSession(response.data.access_token, context);
+    const { customerId } = decodeJwt(response.data.access_token);
+    await Promise.all([
+      mergeBaskets(
+        context.sessionId,
+        await context.generateBasketKeyForUserId(customerId),
+        DEFAULT_WITH_LISTING,
+        context
+      ),
+      mergeWishlists(
+        context.sessionId,
+        await context.generateWishlistKeyForUserId(customerId),
+        DEFAULT_WITH_LISTING,
+        context
+      )
+    ]);
+    await context.createUserBoundSession();
+    return {
+      oauth: response.data
+    };
+  } catch (error) {
+    const err = convertErrorForRpcCall(error, [
+      HttpStatusCode.INTERNAL_SERVER_ERROR,
+      HttpStatusCode.BAD_REQUEST,
+      HttpStatusCode.UNAUTHORIZED,
+      HttpStatusCode.NOT_FOUND
+    ]);
+    if (err) {
+      throw err;
+    }
+    return { oauth: null };
+  }
+};
+export const oauthRegister = async (register, context) => {
+  const shopId = context.shopId;
+  const { axiosInstance: axiosInstance2 } = getOAuthSettings(context);
+  try {
+    const response = await axiosInstance2.post(
+      "/auth/register",
+      {
+        ...register,
+        shop_id: shopId
+      }
+    );
+    context.updateTokens({
+      accessToken: response.data.access_token,
+      refreshToken: response.data.refresh_token
+    });
+    await saveUserOnSession(response.data.access_token, context);
+    const { customerId } = decodeJwt(response.data.access_token);
+    await Promise.all([
+      mergeBaskets(
+        context.sessionId,
+        await context.generateBasketKeyForUserId(customerId),
+        DEFAULT_WITH_LISTING,
+        context
+      ),
+      mergeWishlists(
+        context.sessionId,
+        await context.generateWishlistKeyForUserId(customerId),
+        DEFAULT_WITH_LISTING,
+        context
+      )
+    ]);
+    await context.createUserBoundSession();
+    return {
+      oauth: response.data
+    };
+  } catch (error) {
+    const err = convertErrorForRpcCall(error, [
+      HttpStatusCode.BAD_REQUEST,
+      HttpStatusCode.UNAUTHORIZED,
+      HttpStatusCode.CONFLICT
+    ]);
+    if (err) {
+      throw err;
+    }
+    return { oauth: null };
+  }
+};
+export const oauthGuestLogin = async (guest, context) => {
+  const shopId = context.shopId;
+  const { axiosInstance: axiosInstance2 } = getOAuthSettings(context);
+  try {
+    const response = await axiosInstance2.post(
+      "/auth/login/guest",
+      {
+        ...guest,
+        shop_id: shopId
+      }
+    );
+    context.updateTokens({
+      accessToken: response.data.access_token,
+      refreshToken: response.data.refresh_token
+    });
+    await saveUserOnSession(response.data.access_token, context);
+    const { customerId } = decodeJwt(response.data.access_token);
+    await Promise.all([
+      mergeBaskets(
+        context.sessionId,
+        await context.generateBasketKeyForUserId(customerId),
+        DEFAULT_WITH_LISTING,
+        context
+      ),
+      mergeWishlists(
+        context.sessionId,
+        await context.generateWishlistKeyForUserId(customerId),
+        DEFAULT_WITH_LISTING,
+        context
+      )
+    ]);
+    await context.createUserBoundSession();
+    return {
+      oauth: response.data
+    };
+  } catch (error) {
+    const err = convertErrorForRpcCall(error, [
+      HttpStatusCode.BAD_REQUEST,
+      HttpStatusCode.UNAUTHORIZED,
+      HttpStatusCode.CONFLICT
+    ]);
+    if (err) {
+      throw err;
+    }
+    return { oauth: null };
+  }
+};
+export const refreshAccessToken = async (context) => {
+  const refreshToken = context.refreshToken;
+  const { axiosInstance: axiosInstance2 } = getOAuthSettings(context);
+  if (!refreshToken) {
+    throw new Error("No app refresh token provided");
+  }
+  try {
+    const response = await axiosInstance2.post(
+      "/oauth/token",
+      {
+        grant_type: "refresh_token",
+        refresh_token: refreshToken
+      }
+    );
+    context.updateTokens({
+      accessToken: response.data.access_token,
+      refreshToken: response.data.refresh_token
+    });
+    return response.data;
+  } catch (error) {
+    const err = convertErrorForRpcCall(error, [
+      HttpStatusCode.BAD_REQUEST,
+      HttpStatusCode.UNAUTHORIZED
+    ]);
+    if (err) {
+      throw err;
+    }
+    return null;
+  }
+};
+export const oauthRevokeToken = async (context) => {
+  const accessToken = context.accessToken;
+  if (!accessToken) {
+    throw new Error("No app oauth authentication credentials");
+  }
+  const decodedAccessToken = decodeJwt(accessToken);
+  await context.destroySession();
+  try {
+    await axiosInstance.delete(`/oauth/tokens/${decodedAccessToken.jti}`, {
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+    return { result: true };
+  } catch (error) {
+    const err = convertErrorForRpcCall(error, [
+      HttpStatusCode.BAD_REQUEST,
+      HttpStatusCode.UNAUTHORIZED,
+      HttpStatusCode.NOT_FOUND
+    ]);
+    if (err) {
+      throw err;
+    }
+    return { result: false };
+  }
+};
+export const oauthForgetPassword = async ({ email }, context) => {
+  const shopId = context.shopId;
+  const { axiosInstance: axiosInstance2 } = getOAuthSettings(context);
+  try {
+    const resetUrl = new URL(context.auth.resetPasswordUrl);
+    if (!resetUrl.searchParams.has("hash")) {
+      resetUrl.searchParams.append("hash", "{hash}");
+    } else {
+      resetUrl.searchParams.set("hash", "{hash}");
+    }
+    await axiosInstance2.post("/auth/password/send-reset-email", {
+      email,
+      reset_url: decodeURI(resetUrl.toString()),
+      shop_id: shopId
+    });
+    return { success: true };
+  } catch (error) {
+    const err = convertErrorForRpcCall(error, [
+      HttpStatusCode.BAD_REQUEST,
+      HttpStatusCode.NOT_FOUND,
+      HttpStatusCode.UNAUTHORIZED,
+      HttpStatusCode.FORBIDDEN
+    ]);
+    if (err) {
+      throw err;
+    }
+    return { success: false };
+  }
+};
+export const updatePasswordByHash = async (passwordHash, context) => {
+  const shopId = context.shopId;
+  const { axiosInstance: axiosInstance2 } = getOAuthSettings(context);
+  try {
+    const response = await axiosInstance2.put(
+      "/auth/password/update-by-hash",
+      {
+        ...passwordHash,
+        shop_id: shopId
+      }
+    );
+    context.updateTokens({
+      accessToken: response.data.access_token,
+      refreshToken: response.data.refresh_token
+    });
+    await context.createUserBoundSession();
+    return {
+      oauth: response.data
+    };
+  } catch (error) {
+    const err = convertErrorForRpcCall(error, [
+      HttpStatusCode.BAD_REQUEST,
+      HttpStatusCode.UNAUTHORIZED,
+      HttpStatusCode.NOT_ACCEPTABLE
+    ]);
+    if (err) {
+      throw err;
+    }
+    return { oauth: null };
+  }
+};

package/dist/rpc/methods/shopConfiguration.cjs

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getShopConfiguration = void 0;
+const getShopConfiguration = async function getShopConfiguration2({
+  cached,
+  bapiClient
+}) {
+  return await cached(bapiClient.shopConfiguration.get, {
+    cacheKeyPrefix: "get-shopConfigurations"
+  })();
+};
+exports.getShopConfiguration = getShopConfiguration;

package/dist/rpc/methods/shopConfiguration.d.ts

@@ -0,0 +1,4 @@
+import { ShopConfigurationResponseData } from '@aboutyou/backbone/endpoints/shopconfiguration/shopconfiguration';
+import { RpcHandler } from '../../types';
+declare const getShopConfiguration: RpcHandler<ShopConfigurationResponseData>;
+export { getShopConfiguration };

package/dist/rpc/methods/shopConfiguration.mjs

@@ -0,0 +1,6 @@
+const getShopConfiguration = async function getShopConfiguration2({ cached, bapiClient }) {
+  return await cached(bapiClient.shopConfiguration.get, {
+    cacheKeyPrefix: "get-shopConfigurations"
+  })();
+};
+export { getShopConfiguration };

package/dist/rpc/methods/user.cjs

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.refreshUser = exports.getUser = exports.fetchUser = void 0;
+var _axios = _interopRequireDefault(require("axios"));
+var _httpStatus = require("../../constants/httpStatus.cjs");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const getUser = function getUser2(context) {
+  return {
+    user: context.user
+  };
+};
+exports.getUser = getUser;
+const fetchUser = async function fetchUser2(payload, options) {
+  const {
+    accessToken
+  } = payload;
+  const {
+    checkoutUrl,
+    shopId,
+    accessHeader
+  } = options;
+  const user = await _axios.default.get(`${checkoutUrl}/api/oauth/me`, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "X-Shop-Id": shopId,
+      "Content-Type": "application/json",
+      ...(accessHeader && {
+        "X-Access-Header": accessHeader
+      })
+    }
+  });
+  return {
+    ...user.data,
+    authentication: {
+      ...user.data?.authentication,
+      storefrontAccessToken: accessToken
+    },
+    ...{
+      loginShopId: shopId
+    }
+  };
+};
+exports.fetchUser = fetchUser;
+const refreshUser = async function refreshUser2(context) {
+  const {
+    accessToken,
+    checkout,
+    shopId
+  } = context;
+  const validateStatus = status => {
+    const {
+      OK,
+      MULTIPLE_CHOICES,
+      FORBIDDEN
+    } = _httpStatus.HttpStatusCode;
+    return status >= OK && status < MULTIPLE_CHOICES || status === FORBIDDEN;
+  };
+  const user = await _axios.default.get(`${checkout.url}/api/oauth/me`, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "X-Shop-Id": shopId,
+      "Content-Type": "application/json"
+    },
+    validateStatus
+  });
+  if (user.data.id) {
+    context.updateUser({
+      ...user.data,
+      authentication: {
+        ...user.data?.authentication,
+        storefrontAccessToken: accessToken
+      },
+      ...{
+        loginShopId: shopId
+      }
+    });
+    return {
+      user: user.data
+    };
+  }
+  await context.destroySession();
+  return {
+    user: void 0
+  };
+};
+exports.refreshUser = refreshUser;

package/dist/rpc/methods/user.d.ts

@@ -0,0 +1,20 @@
+import { AuthConfig, RpcContext, RpcHandler, ShopUser } from '../../types';
+declare const getUser: RpcHandler<{
+    user: ShopUser | undefined;
+}>;
+declare const fetchUser: (payload: AuthConfig, options: {
+    checkoutUrl: string;
+    shopId: number;
+    accessHeader?: string | undefined;
+}) => Promise<ShopUser>;
+/**
+ * This function adds a way to force fetch the user from checkout. In case the user is not logged in any longer the session will be destroyed  and the returned user will be undefined.
+ * @param context
+ * @returns ShopUser
+ */
+declare const refreshUser: (context: RpcContext) => Promise<{
+    user: ShopUser;
+} | {
+    user: undefined;
+}>;
+export { getUser, fetchUser, refreshUser };

package/dist/rpc/methods/user.mjs

@@ -0,0 +1,56 @@
+import axios from "axios";
+import { HttpStatusCode } from "../../constants/httpStatus.mjs";
+const getUser = function getUser2(context) {
+  return {
+    user: context.user
+  };
+};
+const fetchUser = async function fetchUser2(payload, options) {
+  const { accessToken } = payload;
+  const { checkoutUrl, shopId, accessHeader } = options;
+  const user = await axios.get(`${checkoutUrl}/api/oauth/me`, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "X-Shop-Id": shopId,
+      "Content-Type": "application/json",
+      ...accessHeader && { "X-Access-Header": accessHeader }
+    }
+  });
+  return {
+    ...user.data,
+    authentication: {
+      ...user.data?.authentication,
+      storefrontAccessToken: accessToken
+    },
+    ...{ loginShopId: shopId }
+  };
+};
+const refreshUser = async function refreshUser2(context) {
+  const { accessToken, checkout, shopId } = context;
+  const validateStatus = (status) => {
+    const { OK, MULTIPLE_CHOICES, FORBIDDEN } = HttpStatusCode;
+    return status >= OK && status < MULTIPLE_CHOICES || status === FORBIDDEN;
+  };
+  const user = await axios.get(`${checkout.url}/api/oauth/me`, {
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "X-Shop-Id": shopId,
+      "Content-Type": "application/json"
+    },
+    validateStatus
+  });
+  if (user.data.id) {
+    context.updateUser({
+      ...user.data,
+      authentication: {
+        ...user.data?.authentication,
+        storefrontAccessToken: accessToken
+      },
+      ...{ loginShopId: shopId }
+    });
+    return { user: user.data };
+  }
+  await context.destroySession();
+  return { user: void 0 };
+};
+export { getUser, fetchUser, refreshUser };

package/dist/rpc/methods/variants.cjs

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getVariantById = void 0;
+const defaultWith = {
+  attributes: "all"
+};
+const getVariantById = async function getVariantById2({
+  ids,
+  include = defaultWith,
+  pricePromotionKey = "default"
+}, {
+  bapiClient,
+  cached,
+  campaignKey,
+  withParams
+}) {
+  const resolvedWith = include ?? withParams?.variant ?? defaultWith;
+  return await cached(bapiClient.variants.getByIds, {
+    cacheKeyPrefix: "getByIds-variants"
+  })(ids, include ? {
+    with: resolvedWith,
+    campaignKey,
+    pricePromotionKey
+  } : void 0);
+};
+exports.getVariantById = getVariantById;

package/dist/rpc/methods/variants.d.ts

@@ -0,0 +1,8 @@
+import type { ProductWith, VariantDetail } from '@aboutyou/backbone';
+import { RpcHandler } from '../../types';
+export interface FetchVariantsParams {
+    ids: number[];
+    include?: ProductWith;
+    pricePromotionKey?: string;
+}
+export declare const getVariantById: RpcHandler<FetchVariantsParams, VariantDetail[]>;

package/dist/rpc/methods/variants.mjs

@@ -0,0 +1,12 @@
+const defaultWith = {
+  attributes: "all"
+};
+export const getVariantById = async function getVariantById2({ ids, include = defaultWith, pricePromotionKey = "default" }, { bapiClient, cached, campaignKey, withParams }) {
+  const resolvedWith = include ?? withParams?.variant ?? defaultWith;
+  return await cached(bapiClient.variants.getByIds, {
+    cacheKeyPrefix: "getByIds-variants"
+  })(
+    ids,
+    include ? { with: resolvedWith, campaignKey, pricePromotionKey } : void 0
+  );
+};

package/dist/rpc/methods/wishlist.cjs

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.removeItemFromWishlist = exports.getWishlist = exports.clearWishlist = exports.addItemToWishlist = void 0;
+var _errors = require("../../errors/index.cjs");
+var _constants = require("../../constants/index.cjs");
+function getWithParams(params, context) {
+  return params.with ?? context.withParams?.basket ?? _constants.MIN_WITH_PARAMS_WISHLIST;
+}
+const addItemToWishlist = async function addItemToWishlist2(options, context) {
+  const {
+    bapiClient,
+    campaignKey,
+    wishlistKey
+  } = context;
+  const {
+    productId,
+    variantId
+  } = options;
+  const resolvedWith = getWithParams(options, context);
+  const pricePromotionKey = resolvedWith?.pricePromotionKey ?? "";
+  if (!productId && !variantId) {
+    throw new Error("No productId or variantId given");
+  }
+  const result = await bapiClient.wishlist.addItem(wishlistKey, variantId ? {
+    variantId
+  } : {
+    productId
+  }, {
+    with: resolvedWith,
+    campaignKey,
+    pricePromotionKey
+  });
+  if (result.type === "success") {
+    return await getWishlist(resolvedWith, context);
+  } else {
+    const {
+      code,
+      message
+    } = result.wishlist;
+    context.log.error("Adding to wishlist failed", result.wishlist);
+    throw new _errors.BAPIError("BAPI ERROR", code, message, "bapiClient.wishlist.addItem");
+  }
+};
+exports.addItemToWishlist = addItemToWishlist;
+const getWishlist = async function getWishlist2(options, context) {
+  const {
+    bapiClient,
+    campaignKey
+  } = context;
+  const resolvedWith = getWithParams({
+    with: options
+  }, context);
+  return await bapiClient.wishlist.get(context.wishlistKey, {
+    with: resolvedWith,
+    campaignKey,
+    pricePromotionKey: resolvedWith?.pricePromotionKey ?? ""
+  });
+};
+exports.getWishlist = getWishlist;
+const removeItemFromWishlist = async function removeItemFromWishlist2(options, context) {
+  const {
+    bapiClient,
+    campaignKey,
+    wishlistKey
+  } = context;
+  const resolvedWith = getWithParams(options, context);
+  return await bapiClient.wishlist.deleteItem(wishlistKey, options.itemKey, {
+    with: resolvedWith,
+    campaignKey
+  });
+};
+exports.removeItemFromWishlist = removeItemFromWishlist;
+const clearWishlist = async function clearWishlist2(context) {
+  const wishlist = await getWishlist({}, context);
+  await Promise.all(wishlist.items.map(async item => {
+    await removeItemFromWishlist({
+      itemKey: item.key
+    }, context);
+  }));
+  return await getWishlist({}, context);
+};
+exports.clearWishlist = clearWishlist;

package/dist/rpc/methods/wishlist.d.ts

@@ -0,0 +1,13 @@
+import type { WishlistResponseData } from '@aboutyou/backbone/endpoints/wishlist/getWishlist';
+import { RpcHandler, WishlistWithOptions } from '../../types';
+export declare const addItemToWishlist: RpcHandler<{
+    variantId?: number;
+    productId?: number;
+    with?: WishlistWithOptions;
+}, WishlistResponseData>;
+export declare const getWishlist: RpcHandler<WishlistWithOptions | undefined, WishlistResponseData>;
+export declare const removeItemFromWishlist: RpcHandler<{
+    itemKey: string;
+    with?: WishlistWithOptions;
+}, ReturnType<typeof getWishlist>>;
+export declare const clearWishlist: RpcHandler<ReturnType<typeof getWishlist>>;