@scayle/storefront-core 7.22.1

package/dist/utils/hash.mjs

@@ -0,0 +1,61 @@
+import { subtle } from "uncrypto";
+export const md5 = async (value) => {
+  if (!process.env.SFC_OMIT_MD5) {
+    const md5EncryptImport = await import("crypto-js/md5");
+    const hexImport = await import("crypto-js/enc-hex");
+    const md5Encrypt = md5EncryptImport.default && typeof md5EncryptImport.default === "function" ? md5EncryptImport.default : md5EncryptImport;
+    const hex = hexImport.default && typeof hexImport.default === "function" ? hexImport.default : hexImport;
+    return hex.stringify(md5Encrypt(value));
+  } else {
+    throw Error("SFC was built without support for MD5");
+  }
+};
+export const sha256 = async (value) => Array.from(
+  new Uint8Array(
+    await subtle.digest("SHA-256", new TextEncoder().encode(value))
+  )
+).map((b) => b.toString(16).padStart(2, "0")).join("");
+export const hmac = async (value, secret, algorithm = "SHA-256") => {
+  const encoder = new TextEncoder();
+  const messageUint8Array = encoder.encode(value);
+  const keyUint8Array = encoder.encode(secret);
+  const cryptoKey = await subtle.importKey(
+    "raw",
+    keyUint8Array,
+    { name: "HMAC", hash: algorithm },
+    false,
+    ["sign"]
+  );
+  const signature = await subtle.sign("HMAC", cryptoKey, messageUint8Array);
+  const hashArray = Array.from(new Uint8Array(signature));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+function base64ToBytes(base64) {
+  const binString = atob(base64);
+  return Uint8Array.from(binString, (m) => m.codePointAt(0));
+}
+function bytesToBase64(bytes) {
+  const binString = Array.from(bytes, (x) => String.fromCodePoint(x)).join("");
+  return btoa(binString);
+}
+export const encodeBase64 = (string) => {
+  if (typeof Buffer === "function") {
+    return Buffer.from(string).toString("base64");
+  }
+  return bytesToBase64(new TextEncoder().encode(string));
+};
+export const decodeBase64 = (string) => {
+  if (typeof Buffer === "function") {
+    return Buffer.from(string, "base64").toString("utf-8");
+  }
+  return new TextDecoder().decode(base64ToBytes(string));
+};
+export const verifyToken = async (token, secret) => {
+  const [encodedPayload, signature] = token.split(".", 2);
+  const expectedSignature = encodeBase64(await hmac(encodedPayload, secret));
+  if (expectedSignature === signature) {
+    return decodeBase64(encodedPayload);
+  }
+};
+export const buildHashPayload = (payload) => encodeBase64(JSON.stringify(payload));
+export const buildSignature = async (payloadHash, secret) => encodeBase64(await hmac(payloadHash, secret));

package/dist/utils/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _timeout = require("./timeout.cjs");
+Object.keys(_timeout).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _timeout[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _timeout[key];
+    }
+  });
+});
+var _log = require("./log.cjs");
+Object.keys(_log).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _log[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _log[key];
+    }
+  });
+});

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from './timeout';
+export * from './log';

package/dist/utils/index.mjs

@@ -0,0 +1,2 @@
+export * from "./timeout.mjs";
+export * from "./log.mjs";

package/dist/utils/keys.cjs

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.generateWishlistKey = exports.generateKey = exports.generateBasketKey = void 0;
+var _hash = require("../constants/hash.cjs");
+var _hash2 = require("./hash.cjs");
+const generateKey = async ({
+  keyTemplate,
+  hashAlgorithm = _hash.HashAlgorithm.MD5,
+  shopId,
+  userId,
+  log
+}) => {
+  if (!shopId) {
+    log?.warn("No shopId provided", {
+      shopId
+    });
+  }
+  if (!userId) {
+    log?.warn("No userId provided", {
+      userId
+    });
+  }
+  const key = String(keyTemplate.replace("{shopId}", shopId).replace("{userId}", userId));
+  if (hashAlgorithm === _hash.HashAlgorithm.MD5) {
+    return await (0, _hash2.md5)(key);
+  }
+  if (hashAlgorithm === _hash.HashAlgorithm.SHA256) {
+    return await (0, _hash2.sha256)(key);
+  }
+  return key;
+};
+exports.generateKey = generateKey;
+const generateWishlistKey = async ({
+  keyTemplate,
+  hashAlgorithm = _hash.HashAlgorithm.MD5,
+  shopId,
+  userId,
+  log
+}) => {
+  return await generateKey({
+    log: log?.space("core.generateWishlistKey"),
+    keyTemplate,
+    hashAlgorithm,
+    shopId,
+    userId
+  });
+};
+exports.generateWishlistKey = generateWishlistKey;
+const generateBasketKey = async ({
+  keyTemplate,
+  hashAlgorithm = _hash.HashAlgorithm.MD5,
+  shopId,
+  userId,
+  log
+}) => {
+  return await generateKey({
+    log: log?.space("core.generateBasketKey"),
+    keyTemplate,
+    hashAlgorithm,
+    shopId,
+    userId
+  });
+};
+exports.generateBasketKey = generateBasketKey;

package/dist/utils/keys.d.ts

@@ -0,0 +1,24 @@
+import type { Log } from '..';
+import { HashAlgorithm } from '../constants/hash';
+export declare const generateKey: ({ keyTemplate, hashAlgorithm, shopId, userId, log, }: {
+    keyName?: string | undefined;
+    keyTemplate: string;
+    hashAlgorithm: HashAlgorithm;
+    shopId: string;
+    userId: string;
+    log?: Log | undefined;
+}) => Promise<any>;
+export declare const generateWishlistKey: ({ keyTemplate, hashAlgorithm, shopId, userId, log, }: {
+    keyTemplate: string;
+    hashAlgorithm: HashAlgorithm;
+    shopId: string;
+    userId: string;
+    log?: Log | undefined;
+}) => Promise<any>;
+export declare const generateBasketKey: ({ keyTemplate, hashAlgorithm, shopId, userId, log, }: {
+    keyTemplate: string;
+    hashAlgorithm: HashAlgorithm;
+    shopId: string;
+    userId: string;
+    log?: Log | undefined;
+}) => Promise<any>;

package/dist/utils/keys.mjs

@@ -0,0 +1,56 @@
+import { HashAlgorithm } from "../constants/hash.mjs";
+import { md5, sha256 } from "./hash.mjs";
+export const generateKey = async ({
+  keyTemplate,
+  hashAlgorithm = HashAlgorithm.MD5,
+  shopId,
+  userId,
+  log
+}) => {
+  if (!shopId) {
+    log?.warn("No shopId provided", { shopId });
+  }
+  if (!userId) {
+    log?.warn("No userId provided", { userId });
+  }
+  const key = String(
+    keyTemplate.replace("{shopId}", shopId).replace("{userId}", userId)
+  );
+  if (hashAlgorithm === HashAlgorithm.MD5) {
+    return await md5(key);
+  }
+  if (hashAlgorithm === HashAlgorithm.SHA256) {
+    return await sha256(key);
+  }
+  return key;
+};
+export const generateWishlistKey = async ({
+  keyTemplate,
+  hashAlgorithm = HashAlgorithm.MD5,
+  shopId,
+  userId,
+  log
+}) => {
+  return await generateKey({
+    log: log?.space("core.generateWishlistKey"),
+    keyTemplate,
+    hashAlgorithm,
+    shopId,
+    userId
+  });
+};
+export const generateBasketKey = async ({
+  keyTemplate,
+  hashAlgorithm = HashAlgorithm.MD5,
+  shopId,
+  userId,
+  log
+}) => {
+  return await generateKey({
+    log: log?.space("core.generateBasketKey"),
+    keyTemplate,
+    hashAlgorithm,
+    shopId,
+    userId
+  });
+};

package/dist/utils/log.cjs

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Log = void 0;
+class Log {
+  static default = new this({
+    space: "global",
+    handler: consoleLogHandler
+  });
+  _handler;
+  _space;
+  _type = "log";
+  constructor(options) {
+    this._handler = options?.handler || Log.default._handler;
+    this._space = options?.space || Log.default._space;
+  }
+  debug(message, data) {
+    this.write("debug", message, data);
+  }
+  info(message, data) {
+    this.write("info", message, data);
+  }
+  warn(message, data) {
+    this.write("warn", message, data);
+  }
+  error(message, data) {
+    const error = message instanceof Error ? message : null;
+    if (error) {
+      data = {
+        error: message,
+        ...data
+      };
+    }
+    this.write("error", error?.message ?? message, data);
+  }
+  write(level, message, data) {
+    if (typeof data !== "undefined") {
+      data = typeof data !== "object" ? {
+        data
+      } : data;
+    }
+    if (this._handler) {
+      this._handler({
+        level,
+        message,
+        data,
+        space: this._space
+      });
+    } else {
+      const logFunc = console[level] || console.log;
+      logFunc.apply(console, data ? [message, data] : [message]);
+    }
+  }
+  /**
+   * Create a new sub-space.
+   * All spaces are being separated by a dot. E.g. `global.api` and `global.api.getUser`
+   * @param subSpace The name of the sub-space in camel-case (e.g. `api` and `api.getUser`)
+   */
+  space(subSpace) {
+    return new Log({
+      space: `${this._space}.${subSpace}`,
+      handler: this._handler
+    });
+  }
+  /**
+   * Measure the time of a function.
+   */
+  async time(message, func) {
+    const start = Date.now();
+    const result = await func();
+    const end = Date.now();
+    this.debug(`${message} took ${end - start}ms`);
+    return result;
+  }
+  /**
+   * Attach the log to the request object: `req.$log`.
+   * This function should be called in a server middleware before storefront-core is initialized.
+   */
+  static attachToRequest(req, log) {
+    req.$log = log;
+  }
+}
+exports.Log = Log;
+function consoleLogHandler({
+  level,
+  message,
+  data
+}) {
+  const logFunc = console[level] || console.log;
+  logFunc.apply(console, data ? [message, data] : [message]);
+}

package/dist/utils/log.d.ts

@@ -0,0 +1,43 @@
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error';
+export interface LogEntry {
+    level: LogLevel;
+    space: string;
+    message: string;
+    data?: Object;
+}
+export type LogHandler = (entry: LogEntry) => void;
+export interface LogOptions {
+    handler?: LogHandler;
+    space: string;
+}
+/**
+ * This log provides a way to log messages to a custom log handler (in a serial manner).
+ * If no handler is provided, it will log to the console.
+ */
+export declare class Log {
+    static default: Log;
+    _handler?: LogHandler;
+    _space: string;
+    _type: string;
+    constructor(options?: LogOptions);
+    debug(message: string, data?: any): void;
+    info(message: string, data?: any): void;
+    warn(message: string, data?: any): void;
+    error(message: string | Error, data?: any): void;
+    write(level: LogLevel, message: string, data?: any): void;
+    /**
+     * Create a new sub-space.
+     * All spaces are being separated by a dot. E.g. `global.api` and `global.api.getUser`
+     * @param subSpace The name of the sub-space in camel-case (e.g. `api` and `api.getUser`)
+     */
+    space(subSpace: string): Log;
+    /**
+     * Measure the time of a function.
+     */
+    time(message: string, func: () => any): Promise<any>;
+    /**
+     * Attach the log to the request object: `req.$log`.
+     * This function should be called in a server middleware before storefront-core is initialized.
+     */
+    static attachToRequest(req: any, log: Log): void;
+}

package/dist/utils/log.mjs

@@ -0,0 +1,75 @@
+export class Log {
+  static default = new this({
+    space: "global",
+    handler: consoleLogHandler
+  });
+  _handler;
+  _space;
+  _type = "log";
+  constructor(options) {
+    this._handler = options?.handler || Log.default._handler;
+    this._space = options?.space || Log.default._space;
+  }
+  debug(message, data) {
+    this.write("debug", message, data);
+  }
+  info(message, data) {
+    this.write("info", message, data);
+  }
+  warn(message, data) {
+    this.write("warn", message, data);
+  }
+  error(message, data) {
+    const error = message instanceof Error ? message : null;
+    if (error) {
+      data = {
+        error: message,
+        ...data
+      };
+    }
+    this.write("error", error?.message ?? message, data);
+  }
+  write(level, message, data) {
+    if (typeof data !== "undefined") {
+      data = typeof data !== "object" ? { data } : data;
+    }
+    if (this._handler) {
+      this._handler({ level, message, data, space: this._space });
+    } else {
+      const logFunc = console[level] || console.log;
+      logFunc.apply(console, data ? [message, data] : [message]);
+    }
+  }
+  /**
+   * Create a new sub-space.
+   * All spaces are being separated by a dot. E.g. `global.api` and `global.api.getUser`
+   * @param subSpace The name of the sub-space in camel-case (e.g. `api` and `api.getUser`)
+   */
+  space(subSpace) {
+    return new Log({
+      space: `${this._space}.${subSpace}`,
+      handler: this._handler
+    });
+  }
+  /**
+   * Measure the time of a function.
+   */
+  async time(message, func) {
+    const start = Date.now();
+    const result = await func();
+    const end = Date.now();
+    this.debug(`${message} took ${end - start}ms`);
+    return result;
+  }
+  /**
+   * Attach the log to the request object: `req.$log`.
+   * This function should be called in a server middleware before storefront-core is initialized.
+   */
+  static attachToRequest(req, log) {
+    req.$log = log;
+  }
+}
+function consoleLogHandler({ level, message, data }) {
+  const logFunc = console[level] || console.log;
+  logFunc.apply(console, data ? [message, data] : [message]);
+}

package/dist/utils/rpc.cjs

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sanitizeErrorObject = exports.convertErrorForRpcCall = void 0;
+var _axios = _interopRequireDefault(require("axios"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const isErrorWithConfig = error => {
+  return !error || error.constructor !== Object || !("config" in error) || !error.config.headers;
+};
+const sanitizeErrorObject = error => {
+  if (!isErrorWithConfig(error)) {
+    return error;
+  }
+  return {
+    ...error,
+    config: {
+      ...error?.config,
+      headers: {
+        ...error.config.headers,
+        Authorization: void 0
+      }
+    }
+  };
+};
+exports.sanitizeErrorObject = sanitizeErrorObject;
+const convertErrorForRpcCall = (error, httpStatuses) => {
+  if (_axios.default.isAxiosError(error) && error.response?.status && httpStatuses.includes(error.response.status)) {
+    const data = Object.assign({
+      code: error.response.status,
+      message: error.response.data
+    }, error.response.data);
+    error.response = {
+      ...error.response,
+      data
+    };
+    return error;
+  }
+};
+exports.convertErrorForRpcCall = convertErrorForRpcCall;

package/dist/utils/rpc.d.ts

@@ -0,0 +1,6 @@
+export declare const sanitizeErrorObject: (error: object) => object;
+/**
+ * It is important to convert error to the format that catch in rpcCall expects,
+ * rpcCall waits for code and message be present in the error otherwise it falls back to 500
+ */
+export declare const convertErrorForRpcCall: (error: any, httpStatuses: Array<number>) => Error;

package/dist/utils/rpc.mjs

@@ -0,0 +1,35 @@
+import axios from "axios";
+const isErrorWithConfig = (error) => {
+  return !error || error.constructor !== Object || !("config" in error) || !error.config.headers;
+};
+export const sanitizeErrorObject = (error) => {
+  if (!isErrorWithConfig(error)) {
+    return error;
+  }
+  return {
+    ...error,
+    config: {
+      ...error?.config,
+      headers: {
+        ...error.config.headers,
+        Authorization: void 0
+      }
+    }
+  };
+};
+export const convertErrorForRpcCall = (error, httpStatuses) => {
+  if (axios.isAxiosError(error) && error.response?.status && httpStatuses.includes(error.response.status)) {
+    const data = Object.assign(
+      {
+        code: error.response.status,
+        message: error.response.data
+      },
+      error.response.data
+    );
+    error.response = {
+      ...error.response,
+      data
+    };
+    return error;
+  }
+};

package/dist/utils/timeout.cjs

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.wait = exports.timeout = void 0;
+const wait = ms => {
+  return new Promise(resolve => setTimeout(resolve, ms));
+};
+exports.wait = wait;
+const timeout = (ms, promise) => {
+  const breaker = new Promise((_resolve, reject) => {
+    setTimeout(() => reject(new Error("timeout")), ms);
+  });
+  return Promise.race([promise, breaker]);
+};
+exports.timeout = timeout;

package/dist/utils/timeout.d.ts

@@ -0,0 +1,2 @@
+export declare const wait: (ms: number) => Promise<unknown>;
+export declare const timeout: (ms: number, promise: Promise<any>) => Promise<any>;

package/dist/utils/timeout.mjs

@@ -0,0 +1,9 @@
+export const wait = (ms) => {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+};
+export const timeout = (ms, promise) => {
+  const breaker = new Promise((_resolve, reject) => {
+    setTimeout(() => reject(new Error("timeout")), ms);
+  });
+  return Promise.race([promise, breaker]);
+};

package/dist/utils/user.cjs

@@ -0,0 +1,75 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeWishlists = exports.mergeBaskets = void 0;
+var _constants = require("../constants/index.cjs");
+const mergeBaskets = async (fromBasketKey, toBasketKey, withOptions, context) => {
+  const {
+    bapiClient,
+    campaignKey
+  } = context;
+  const fromOriginBasket = await bapiClient.basket.get(fromBasketKey, {
+    with: withOptions,
+    campaignKey
+  });
+  context.log.debug(`Merging basket ${fromBasketKey} to ${toBasketKey}`);
+  if (fromBasketKey === toBasketKey) {
+    return fromOriginBasket;
+  }
+  const {
+    basket: fromBasket,
+    type
+  } = fromOriginBasket;
+  if (type === "success" && fromBasket?.items?.length > 0) {
+    const itemsToAddOrUpdate = fromBasket.items.map(item => ({
+      variantId: item.variant.id,
+      quantity: item.quantity,
+      params: {
+        promotionId: item.promotionId,
+        customData: item.customData,
+        displayData: item.displayData,
+        itemGroup: item.itemGroup,
+        pricePromotionKey: withOptions.pricePromotionKey
+      }
+    }));
+    const mergedBasket = await bapiClient.basket.addOrUpdateItems(toBasketKey, itemsToAddOrUpdate, {
+      with: withOptions,
+      campaignKey,
+      includeItemsWithoutProductData: withOptions?.includeItemsWithoutProductData
+    }, {
+      existingItemHandling: _constants.ExistingItemHandling.AddQuantityToExisting
+    });
+    fromBasket.items.map(async item => {
+      return await bapiClient.basket.deleteItem(fromBasketKey, item.key);
+    });
+    return mergedBasket;
+  }
+};
+exports.mergeBaskets = mergeBaskets;
+const mergeWishlists = async (fromWishlistKey, toWishlistKey, withOptions, context) => {
+  const {
+    bapiClient,
+    campaignKey
+  } = context;
+  const oldWishlist = await bapiClient.wishlist.get(fromWishlistKey, {
+    with: withOptions,
+    campaignKey
+  });
+  context.log.debug(`Merging wishlist ${fromWishlistKey} to ${toWishlistKey}`);
+  if (oldWishlist != null) {
+    for (const item of oldWishlist.items) {
+      const productId = item?.product?.id;
+      if (productId) {
+        await bapiClient.wishlist.addItem(toWishlistKey, {
+          productId
+        }, {
+          campaignKey
+        });
+        bapiClient.wishlist.deleteItem(fromWishlistKey, item?.key);
+      }
+    }
+  }
+};
+exports.mergeWishlists = mergeWishlists;

package/dist/utils/user.d.ts

@@ -0,0 +1,14 @@
+import { BasketWithOptions, RpcContext } from '../types';
+export declare const mergeBaskets: (fromBasketKey: string, toBasketKey: string, withOptions: BasketWithOptions, context: RpcContext) => Promise<{
+    type: "failure";
+    statusCode: number;
+    basket: import("@aboutyou/backbone/endpoints/basket/getBasket").BasketResponseData<import("@aboutyou/backbone/types/BapiProduct").BapiProduct, import("@aboutyou/backbone/types/BapiProduct").Variant>;
+} | {
+    readonly type: "success";
+    readonly basket: import("@aboutyou/backbone/endpoints/basket/getBasket").BasketResponseData<import("@aboutyou/backbone/types/BapiProduct").BapiProduct, import("@aboutyou/backbone/types/BapiProduct").Variant>;
+} | {
+    readonly type: "failure";
+    readonly basket: import("@aboutyou/backbone/endpoints/basket/getBasket").BasketResponseData<import("@aboutyou/backbone/types/BapiProduct").BapiProduct, import("@aboutyou/backbone/types/BapiProduct").Variant>;
+    readonly errors: import("@aboutyou/backbone/helpers/BapiClient").AddOrUpdateItemError[];
+} | undefined>;
+export declare const mergeWishlists: (fromWishlistKey: string, toWishlistKey: string, withOptions: BasketWithOptions, context: RpcContext) => Promise<void>;