@scayle/storefront-core 7.44.0 → 7.45.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @scayle/storefront-core
 
+## 7.45.0
+
+### Minor Changes
+
+- Improve typing of RPC methods by using `satisfies` instead of assertions. The [`satisfies` operator](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-9.html) validates that an expression matches a type without changing the type of that expression. For RPC methods it can be used to enforce that a function conforms to the spec of an RPC method, without affecting the more specific inferred type of the function.
+
+  You can use this pattern in your own custom RPC methods as well.
+
+  For example:
+
+  ```
+  export const custom: RpcHandler<{ shop: number }> = (
+    context: RpcContext,
+  ) => {
+    return {
+      shop: context.shopId,
+    }
+  }
+  ```
+
+  ```
+  export const custom = (
+    context: RpcContext,
+  ) => {
+    return {
+      shop: context.shopId,
+    }
+  } satisfies RpcHandler<{ shop: number }>
+  ```
+
+  In the first case, `custom` will be typed as `RpcHandler<{shop: number}>` or essentially a function takes no parameters and returns `{ shop: number } | Response<{shop: number}>`. In the second case, it will be typed as a function which takes no parameters and returns `{ shop: number }` which is more specific. The more specific typing may be useful if you are calling the custom RPC function as both a registered RPC method and regular function.
+
+## 7.44.1
+
+### Patch Changes
+
+- Updated dependencies
+  - @aboutyou/backbone@16.2.0
+
 ## 7.44.0
 
 ### Minor Changes

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

@@ -1,23 +1,35 @@
-import { AddOrUpdateItemType, BasketResponseData, BasketWithOptions, Product, Variant, RpcHandler } from '../../../types';
+import { AddOrUpdateItemError } from '@aboutyou/backbone/helpers/BapiClient';
+import { AddOrUpdateItemType, BasketResponseData, BasketWithOptions, Product, Variant, RpcContext } from '../../../types';
 import { ExistingItemHandling } from '../../../constants';
-export declare const addItemToBasket: RpcHandler<AddOrUpdateItemType & {
-    existingItemHandling?: ExistingItemHandling;
-    with?: BasketWithOptions;
-}, BasketResponseData<Product, Variant>>;
-export declare const addItemsToBasket: RpcHandler<{
+export declare const addItemToBasket: ({ variantId, promotionId, quantity, displayData, customData, existingItemHandling, itemGroup, with: _with, }: AddOrUpdateItemType & {
+    existingItemHandling?: 0 | 1 | 2 | 3 | undefined;
+    with?: BasketWithOptions | undefined;
+}, context: RpcContext) => Promise<BasketResponseData<Product, Variant>>;
+export declare const addItemsToBasket: (params: {
     items: AddOrUpdateItemType[];
     existingItemHandling: ExistingItemHandling;
-    with?: BasketWithOptions;
-    considerItemGroupForUniqueness?: boolean;
-}, BasketResponseData<Product, Variant>>;
-export declare const getBasket: RpcHandler<BasketWithOptions | undefined, BasketResponseData<Product, Variant>>;
-export declare const removeItemFromBasket: RpcHandler<{
+    with?: BasketWithOptions | undefined;
+    considerItemGroupForUniqueness?: boolean | undefined;
+}, context: RpcContext) => Promise<BasketResponseData<Product, Variant>>;
+export declare const getBasket: (options: BasketWithOptions | undefined, context: RpcContext) => Promise<BasketResponseData<Product, Variant>>;
+export declare const removeItemFromBasket: (options: {
     itemKey: string;
-    with?: BasketWithOptions;
-}, BasketResponseData<Product, Variant>>;
-export declare const clearBasket: RpcHandler<boolean>;
-export declare const mergeBaskets: RpcHandler<{
+    with?: BasketWithOptions | undefined;
+}, context: RpcContext) => Promise<BasketResponseData<Product, Variant>>;
+export declare const clearBasket: (context: RpcContext) => Promise<boolean>;
+export declare const mergeBaskets: ({ fromBasketKey, toBasketKey, with: _with }: {
     fromBasketKey: string;
     toBasketKey: string;
-    with?: BasketWithOptions;
-}, any>;
+    with?: BasketWithOptions | undefined;
+}, context: RpcContext) => Promise<{
+    type: "failure";
+    statusCode: number;
+    basket: BasketResponseData<Product, Variant>;
+} | {
+    readonly type: "success";
+    readonly basket: BasketResponseData<Product, Variant>;
+} | {
+    readonly type: "failure";
+    readonly basket: BasketResponseData<Product, Variant>;
+    readonly errors: AddOrUpdateItemError[];
+} | undefined>;

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

@@ -1,5 +1,5 @@
-import { Brand, BrandsEndpointRequestParameters, BrandsEndpointResponseData, RpcHandler } from '../../types';
-export declare const getBrands: RpcHandler<BrandsEndpointRequestParameters, BrandsEndpointResponseData>;
-export declare const getBrandById: RpcHandler<{
+import { Brand, BrandsEndpointRequestParameters, BrandsEndpointResponseData } from '../../types';
+export declare const getBrands: ({ pagination }: BrandsEndpointRequestParameters, { bapiClient, cached }: import("../../types").RpcContext) => Promise<BrandsEndpointResponseData>;
+export declare const getBrandById: ({ brandId }: {
     brandId: number;
-}, Brand>;
+}, { bapiClient, cached }: import("../../types").RpcContext) => Promise<Brand>;

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

@@ -1,26 +1,29 @@
-import { Category, RpcHandler } from '../../types';
-export declare const getRootCategories: RpcHandler<{
-    children?: number;
-    includeHidden?: true;
-}, {
+import { Category } from '../../types';
+export declare const getRootCategories: ({ children, includeHidden }: {
+    children?: number | undefined;
+    includeHidden?: true | undefined;
+}, { cached, bapiClient }: import("../../types").RpcContext) => Promise<{
     categories: Category[];
     activeNode: undefined;
 }>;
-export declare const getCategoryByPath: RpcHandler<{
+export declare const getCategoryByPath: ({ path, children, includeHidden }: {
     path: string;
-    children?: number;
-    includeHidden?: true;
-}, Category | undefined>;
-export declare const getCategoriesByPath: RpcHandler<{
+    children?: number | undefined;
+    includeHidden?: true | undefined;
+}, context: import("../../types").RpcContext) => Promise<Category>;
+export declare const getCategoriesByPath: ({ path, children, includeHidden }: {
     path: string;
-    children?: number;
-    includeHidden?: true;
-}, {
-    categories: Category[] | Category;
-    activeNode: Category | undefined;
+    children?: number | undefined;
+    includeHidden?: true | undefined;
+}, context: import("../../types").RpcContext) => Promise<{
+    categories: Category[];
+    activeNode: undefined;
+} | {
+    categories: Category;
+    activeNode: Category;
 }>;
-export declare const getCategoryById: RpcHandler<{
+export declare const getCategoryById: ({ id, children, includeHidden }: {
     id: number;
-    children?: number;
-    includeHidden?: true;
-}, Category>;
+    children?: number | undefined;
+    includeHidden?: true | undefined;
+}, context: import("../../types").RpcContext) => Promise<Category>;

package/dist/rpc/methods/checkout/order.d.ts

@@ -1,4 +1,4 @@
-import { Order, RpcHandler } from '../../../types';
-export declare const getOrderById: RpcHandler<{
+import { Order } from '../../../types';
+export declare const getOrderById: ({ orderId }: {
     orderId: number;
-}, Order>;
+}, context: import("../../../types").RpcContext) => Promise<Order>;

package/dist/rpc/methods/checkout/shopUser.d.ts

@@ -1,7 +1,7 @@
-import type { UpdatePasswordParams, RpcHandler, ShopUser } from '../../../types';
-export declare const updateShopUser: RpcHandler<Partial<ShopUser>, {
+import type { UpdatePasswordParams, ShopUser } from '../../../types';
+export declare const updateShopUser: (payload: Partial<ShopUser>, context: import("../../../types").RpcContext) => Promise<{
     user: ShopUser;
 }>;
-export declare const updatePassword: RpcHandler<UpdatePasswordParams, {
+export declare const updatePassword: ({ oldPassword, newPassword }: UpdatePasswordParams, context: import("../../../types").RpcContext) => Promise<{
     user: ShopUser | undefined;
 }>;

package/dist/rpc/methods/checkout/shopUserAddresses.d.ts

@@ -1,3 +1,3 @@
-import type { RpcHandler, ShopUserAddress } from '../../../types';
-declare const getShopUserAddresses: RpcHandler<ShopUserAddress[]>;
+import type { ShopUserAddress } from '../../../types';
+declare const getShopUserAddresses: (context: import("../../../types").RpcContext) => Promise<ShopUserAddress[]>;
 export { getShopUserAddresses };

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

@@ -1,5 +1,5 @@
 import type { NavigationTree } from '@aboutyou/backbone/types/navigation';
 import type { NavigationAllEndpointResponseData } from '@aboutyou/backbone/endpoints/navigation/navigation';
-import { FetchNavigationTreesParams, FetchNavigationTreeByIdParams, RpcHandler } from '../../types';
-export declare const fetchAllNavigationTrees: RpcHandler<FetchNavigationTreesParams, NavigationAllEndpointResponseData>;
-export declare const fetchNavigationTreeById: RpcHandler<FetchNavigationTreeByIdParams, NavigationTree>;
+import { FetchNavigationTreesParams, FetchNavigationTreeByIdParams } from '../../types';
+export declare const fetchAllNavigationTrees: ({ params }: FetchNavigationTreesParams, { bapiClient: { navigation }, cached }: import("../../types").RpcContext) => Promise<NavigationAllEndpointResponseData>;
+export declare const fetchNavigationTreeById: ({ treeId, params }: FetchNavigationTreeByIdParams, { bapiClient: { navigation }, cached }: import("../../types").RpcContext) => Promise<NavigationTree>;

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

@@ -1,13 +1,22 @@
-import { FetchFiltersParams, FetchFiltersResponse, FetchProductParams, FetchProductsByCategoryParams, FetchProductsByCategoryResponse, FetchProductsCountParams, FetchProductsCountResponse, FetchProductsParams, Product, RpcHandler } from '../../types';
-export declare const getProductById: RpcHandler<FetchProductParams, Product>;
-export declare const getProductsByIds: RpcHandler<FetchProductsParams, Product[]>;
-export declare const getProductsByCategory: RpcHandler<FetchProductsByCategoryParams, FetchProductsByCategoryResponse>;
-export declare const getFilters: RpcHandler<FetchFiltersParams, FetchFiltersResponse>;
-export declare const fetchAllFiltersForCategory: RpcHandler<{
-    includedFilters?: string[];
+import type { FiltersEndpointResponseData } from '@aboutyou/backbone/endpoints/filters/filters';
+import { FetchFiltersParams, FetchProductParams, FetchProductsByCategoryParams, FetchProductsCountParams, FetchProductsParams, Product, RpcContext } from '../../types';
+export declare const getProductById: (options: FetchProductParams, { bapiClient, cached, campaignKey, withParams }: RpcContext) => Promise<Product>;
+export declare const getProductsByIds: (options: FetchProductsParams, { bapiClient, cached, campaignKey, withParams }: RpcContext) => Promise<Product[]>;
+export declare const getProductsByCategory: ({ category, cache, with: _with, perPage, page, where, sort, pricePromotionKey, includeSellableForFree, includeSoldOut, orFiltersOperator, }: FetchProductsByCategoryParams, context: RpcContext) => Promise<{
+    products: Product[];
+    pagination: import("@aboutyou/backbone/endpoints/products/productsByIds").Pagination;
+}>;
+export declare const getFilters: ({ category, includedFilters, where, includeSoldOut, includeSellableForFree, orFiltersOperator, }: FetchFiltersParams, context: RpcContext) => Promise<{
+    filters: FiltersEndpointResponseData;
+    unfilteredCount: number;
+}>;
+export declare const fetchAllFiltersForCategory: ({ includedFilters, category }: {
+    includedFilters?: string[] | undefined;
     category: {
         slug: string;
         id: number;
     };
-}, string[]>;
-export declare const getProductsCount: RpcHandler<FetchProductsCountParams, FetchProductsCountResponse>;
+}, { cached, bapiClient, campaignKey }: RpcContext) => Promise<string[]>;
+export declare const getProductsCount: ({ category, categoryId, where, includeSoldOut, includeSellableForFree, orFiltersOperator, }: FetchProductsCountParams, { cached, bapiClient, campaignKey }: RpcContext) => Promise<{
+    count: number;
+}>;

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

@@ -1,4 +1,4 @@
-import { RpcHandler, PromotionsParams, PromotionsResponseData } from '../../types';
-export declare const getPromotions: RpcHandler<Omit<PromotionsParams, 'ids'>, PromotionsResponseData>;
-export declare const getCurrentPromotions: RpcHandler<Omit<PromotionsParams, 'ids' | 'activeAt'>, PromotionsResponseData>;
-export declare const getPromotionsByIds: RpcHandler<string[], PromotionsResponseData>;
+import { PromotionsParams, PromotionsResponseData } from '../../types';
+export declare const getPromotions: (params: Omit<PromotionsParams, "ids"> | undefined, context: import("../../types").RpcContext) => Promise<PromotionsResponseData>;
+export declare const getCurrentPromotions: (params: Omit<PromotionsParams, "ids" | "activeAt"> | undefined, context: import("../../types").RpcContext) => Promise<PromotionsResponseData>;
+export declare const getPromotionsByIds: (ids: string[], context: import("../../types").RpcContext) => Promise<PromotionsResponseData>;

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

@@ -1,10 +1,9 @@
 import type { TypeaheadSuggestionsEndpointRequestParameters, TypeaheadSuggestionsEndpointResponseData } from '@aboutyou/backbone/endpoints/typeahead/typeahead';
-import { RpcHandler } from '../../types';
 type SearchWith = TypeaheadSuggestionsEndpointRequestParameters['with'];
-export declare const searchProducts: RpcHandler<{
+export declare const searchProducts: ({ term, slug, with: _with, productLimit }: {
     term: string;
-    slug?: string;
+    slug?: string | undefined;
     with?: SearchWith;
-    productLimit?: number;
-}, TypeaheadSuggestionsEndpointResponseData>;
+    productLimit?: number | undefined;
+}, { cached, bapiClient, withParams }: import("../../types").RpcContext) => Promise<TypeaheadSuggestionsEndpointResponseData>;
 export {};

package/dist/rpc/methods/session.cjs

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.updatePasswordByHash = exports.refreshAccessToken = exports.oauthRevokeToken = exports.oauthRegister = exports.oauthLogin = exports.oauthGuestLogin = exports.oauthForgetPassword = exports.convertErrorForRpcCall = void 0;
+exports.updatePasswordByHash = exports.refreshAccessToken = exports.oauthRevokeToken = exports.oauthRegister = exports.oauthLogin = exports.oauthGuestLogin = exports.oauthForgetPassword = void 0;
 var _jose = require("jose");
 var _types = require("../../types/index.cjs");
 var _constants = require("../../constants/index.cjs");
@@ -19,7 +19,6 @@ const convertErrorForRpcCall = (error, httpStatuses) => {
     });
   }
 };
-exports.convertErrorForRpcCall = convertErrorForRpcCall;
 async function postLogin(context, tokens) {
   const user = await (0, _response.unwrap)((0, _user2.fetchUser)({
     accessToken: tokens.access_token,

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

@@ -1,21 +1,23 @@
 import type { Optional } from 'utility-types';
-import type { GuestRequest, LoginRequest, ParamRpcHandler, RegisterRequest, RpcHandler, UpdatePasswordByHashRequest } from '../../types';
-/**
- * Ensure error is a fetch error with one of the status codes
- */
-export declare const convertErrorForRpcCall: (error: any, httpStatuses: Array<number>) => Response | undefined;
-export declare const oauthLogin: ParamRpcHandler<Optional<LoginRequest, 'shop_id'>, undefined>;
-export declare const oauthRegister: ParamRpcHandler<Optional<RegisterRequest, 'shop_id'>, undefined>;
-export declare const oauthGuestLogin: ParamRpcHandler<Optional<GuestRequest, 'shop_id'>, undefined>;
-export declare const refreshAccessToken: RpcHandler<{
-    success: boolean;
+import type { GuestRequest, LoginRequest, RegisterRequest, RpcContext, UpdatePasswordByHashRequest } from '../../types';
+export declare const oauthLogin: (login: Optional<LoginRequest, "shop_id">, context: RpcContext) => Promise<Response>;
+export declare const oauthRegister: (register: Optional<RegisterRequest, "shop_id">, context: RpcContext) => Promise<Response>;
+export declare const oauthGuestLogin: (guest: Optional<GuestRequest, "shop_id">, context: RpcContext) => Promise<Response>;
+export declare const refreshAccessToken: (context: RpcContext) => Promise<Response | {
+    success: true;
+} | {
+    success: false;
 }>;
-export declare const oauthRevokeToken: RpcHandler<{
-    result: boolean;
+export declare const oauthRevokeToken: (context: RpcContext) => Promise<Response | {
+    result: true;
+} | {
+    result: false;
 }>;
-export declare const oauthForgetPassword: RpcHandler<{
+export declare const oauthForgetPassword: ({ email }: {
     email: string;
-}, {
-    success: boolean;
+}, context: RpcContext) => Promise<Response | {
+    success: true;
+} | {
+    success: false;
 }>;
-export declare const updatePasswordByHash: ParamRpcHandler<Optional<UpdatePasswordByHashRequest, 'shop_id'>, undefined>;
+export declare const updatePasswordByHash: (passwordHash: Optional<UpdatePasswordByHashRequest, "shop_id">, context: RpcContext) => Promise<Response>;

package/dist/rpc/methods/session.mjs

@@ -6,7 +6,7 @@ import { mergeBaskets, mergeWishlists } from "../../utils/user.mjs";
 import { fetchUser } from "../../rpc/methods/user.mjs";
 import { unwrap } from "../../utils/response.mjs";
 import { getOAuthClient } from "../../api/oauth.mjs";
-export const convertErrorForRpcCall = (error, httpStatuses) => {
+const convertErrorForRpcCall = (error, httpStatuses) => {
   if (error instanceof FetchError && httpStatuses.includes(error.response.status)) {
     return new Response(null, { status: error.response.status });
   }

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

@@ -1,4 +1,4 @@
 import { ShopConfigurationResponseData } from '@aboutyou/backbone/endpoints/shopconfiguration/shopconfiguration';
-import { RpcHandler } from '../../types';
-declare const getShopConfiguration: RpcHandler<ShopConfigurationResponseData>;
+import { RpcContext } from '../../types';
+declare const getShopConfiguration: ({ cached, bapiClient }: RpcContext) => Promise<ShopConfigurationResponseData>;
 export { getShopConfiguration };

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

@@ -1,15 +1,17 @@
-import type { AuthConfig, RpcHandler, ShopUser } from '../../types';
-declare const getUser: RpcHandler<{
+import type { AuthConfig, RpcContext, ShopUser } from '../../types';
+declare const getUser: (context: RpcContext) => {
     user: ShopUser | undefined;
-}>;
-declare const fetchUser: RpcHandler<AuthConfig, ShopUser>;
+};
+declare const fetchUser: (payload: AuthConfig, context: RpcContext) => 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: RpcHandler<{
-    user: ShopUser | undefined;
+declare const refreshUser: (context: RpcContext) => Promise<{
+    user: undefined;
+} | {
+    user: ShopUser;
 }>;
 export { getUser, fetchUser, refreshUser };

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

@@ -1,9 +1,9 @@
 import type { ProductWith } from '@aboutyou/backbone';
 import type { VariantDetail } from '@aboutyou/backbone/endpoints/variants/variantsByIds';
-import { RpcHandler } from '../../types';
+import { RpcContext } from '../../types';
 export interface FetchVariantsParams {
     ids: number[];
     include?: ProductWith;
     pricePromotionKey?: string;
 }
-export declare const getVariantById: RpcHandler<FetchVariantsParams, VariantDetail[]>;
+export declare const getVariantById: ({ ids, include, pricePromotionKey }: FetchVariantsParams, { bapiClient, cached, campaignKey, withParams }: RpcContext) => Promise<VariantDetail[]>;

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/storefront-core",
-  "version": "7.44.0",
+  "version": "7.45.0",
   "description": "Collection of essential utilities to work with the Storefront API",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -59,10 +59,10 @@
     "test:ci": "vitest --run --passWithNoTests --coverage --reporter=default --reporter=junit"
   },
   "dependencies": {
-    "@aboutyou/backbone": "16.1.2",
+    "@aboutyou/backbone": "16.2.0",
     "crypto-js": "4.2.0",
-    "jose": "5.2.2",
-    "radash": "12.0.0",
+    "jose": "5.2.3",
+    "radash": "12.1.0",
     "slugify": "1.6.6",
     "ufo": "1.4.0",
     "uncrypto": "0.1.3",
@@ -71,7 +71,7 @@
   "devDependencies": {
     "@scayle/eslint-config-storefront": "3.2.6",
     "@types/crypto-js": "4.2.2",
-    "@types/node": "20.11.24",
+    "@types/node": "20.11.28",
     "@types/webpack-env": "1.18.4",
     "@vitest/coverage-v8": "1.3.1",
     "dprint": "0.45.0",
@@ -80,7 +80,7 @@
     "publint": "0.2.7",
     "rimraf": "5.0.5",
     "ts-node": "10.9.2",
-    "typescript": "5.3.3",
+    "typescript": "5.4.2",
     "unbuild": "2.0.0",
     "unstorage": "1.10.1",
     "vitest": "1.3.1"