@scayle/storefront-nuxt 7.82.0 → 7.82.2

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @scayle/storefront-nuxt
 
+## 7.82.2
+
+### Patch Changes
+
+- Fix types of `useBasket` composable
+- Fix types for more composables
+- Migrate from using `RpcContext.bapiClient` to using `RpcContext.sapiClient`
+- Updated dependencies
+  - @scayle/storefront-core@7.62.0
+
+## 7.82.1
+
+### Patch Changes
+
+- Fix types of `useBasket` composable
+- Updated dependencies
+  - @scayle/storefront-core@7.61.0
+
 ## 7.82.0
 
 ### Minor Changes
@@ -69,27 +87,27 @@
   Hooks can be registered by adding a nitro plugin inside ´server/plugins/´:
 
   ```ts
-  import { defineNitroPlugin } from "#imports";
+  import { defineNitroPlugin } from '#imports'
 
   export default defineNitroPlugin((nitroApp) => {
-    nitroApp.hooks.hook("storefront:rpc:before", (rpcName, rpcContext) => {
-      rpcContext.log.debug(`Before: ${rpcName}`);
-    });
+    nitroApp.hooks.hook('storefront:rpc:before', (rpcName, rpcContext) => {
+      rpcContext.log.debug(`Before: ${rpcName}`)
+    })
 
     nitroApp.hooks.hook(
-      "storefront:rpc:after",
+      'storefront:rpc:after',
       (rpcName, rpcContext, result) => {
-        rpcContext.log.debug(`After: ${rpcName} returned ${result}`);
-      }
-    );
+        rpcContext.log.debug(`After: ${rpcName} returned ${result}`)
+      },
+    )
 
     nitroApp.hooks.hook(
-      "storefront:rpc:error",
+      'storefront:rpc:error',
       (rpcName, rpcContext, error) => {
-        rpcContext.log.error(`ERROR: ${rpcName} did throw ${error}`);
-      }
-    );
-  });
+        rpcContext.log.error(`ERROR: ${rpcName} did throw ${error}`)
+      },
+    )
+  })
   ```
 
   Added [`callHook`](https://github.com/unjs/hookable?tab=readme-ov-file#async-callhook-name-args), `callHookParallel` and [`callHookWith`](https://github.com/unjs/hookable?tab=readme-ov-file#callhookwith-name-callerfn) to `RpcContext` to allow triggering hooks within RPCs
@@ -357,20 +375,20 @@
 - It is now also possible to extend the RPCContext using the `storefront:context:created` nitro runtime hook.
 
   ```ts
-  import { defineNitroPlugin } from "nitropack/runtime/plugin";
+  import { defineNitroPlugin } from 'nitropack/runtime/plugin'
   // Augment RpxContext type
-  declare module "@scayle/storefront-nuxt" {
+  declare module '@scayle/storefront-nuxt' {
     interface AdditionalRpcContext {
-      myNewProp: string;
+      myNewProp: string
     }
   }
 
   // Set new value on rpcContext
   export default defineNitroPlugin((nitroApp) => {
-    nitroApp.hooks.hook("storefront:context:created", (rpcContext) => {
-      rpcContext.myNewProp = "My campaign key";
-    });
-  });
+    nitroApp.hooks.hook('storefront:context:created', (rpcContext) => {
+      rpcContext.myNewProp = 'My campaign key'
+    })
+  })
   ```
 
 ### Patch Changes
@@ -573,8 +591,8 @@
 
   ```ts
   const { data: externalIDPRedirects } = await useIDP({
-    queryParams: { redirectTo: "/account" },
-  });
+    queryParams: { redirectTo: '/account' },
+  })
   ```
 
   Please note that `code` and `state` are not supported as these are used by the SCAYLE Authentication API.
@@ -993,16 +1011,16 @@ There is an `unwrap` function exported by this package (>=7.55.0) that can be us
   Before:
 
   ```typescript
-  toCurrency(100, { currency: "EUR" });
-  formatPrice(100, { currencyFractionDigits: 2 });
+  toCurrency(100, { currency: 'EUR' })
+  formatPrice(100, { currencyFractionDigits: 2 })
   ```
 
   After:
 
   ```typescript
-  const { formatCurrency } = useFormatHelpers();
-  formatCurrency(100, { currency: "EUR" });
-  formatCurrency(100, { style: "decimal", currencyFractionDigits: 2 });
+  const { formatCurrency } = useFormatHelpers()
+  formatCurrency(100, { currency: 'EUR' })
+  formatCurrency(100, { style: 'decimal', currencyFractionDigits: 2 })
   ```
 
 ## 7.44.1

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.ed010583.mjs';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.87331293.mjs';
 export { rpcCall } from './rpc.mjs';
 export * from '@scayle/storefront-core';
 export { LogLevel } from '@scayle/storefront-core';

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.ed010583.js';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, M as ModuleBaseOptions, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.87331293.js';
 export { rpcCall } from './rpc.js';
 export * from '@scayle/storefront-core';
 export { LogLevel } from '@scayle/storefront-core';

package/dist/module.d.mts

@@ -1,11 +1,11 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleBaseOptions } from './shared/storefront-nuxt.ed010583.mjs';
-export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.ed010583.mjs';
+import { M as ModuleBaseOptions } from './shared/storefront-nuxt.87331293.mjs';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.87331293.mjs';
 export { LogLevel } from '@scayle/storefront-core';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
 import 'zod';
 
-declare const _default: _nuxt_schema.NuxtModule<ModuleBaseOptions>;
+declare const _default: _nuxt_schema.NuxtModule<Omit<ModuleBaseOptions, "sapi" | "bapi">>;
 
 export { ModuleBaseOptions, _default as default };

package/dist/module.d.ts

@@ -1,11 +1,11 @@
 import * as _nuxt_schema from '@nuxt/schema';
-import { M as ModuleBaseOptions } from './shared/storefront-nuxt.ed010583.js';
-export { d as AdditionalShopConfig, A as AppKeys, B as BapiConfig, h as CheckoutEvent, C as CheckoutShopConfig, i as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, a as SessionConfig, e as ShopConfig, f as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, g as StorefrontConfig } from './shared/storefront-nuxt.ed010583.js';
+import { M as ModuleBaseOptions } from './shared/storefront-nuxt.87331293.js';
+export { e as AdditionalShopConfig, A as AppKeys, B as BapiConfig, i as CheckoutEvent, C as CheckoutShopConfig, j as ModulePublicRuntimeConfig, P as PublicShopConfig, R as RedisConfig, d as SapiConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, c as StorageConfig, b as StorageEntity, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.87331293.js';
 export { LogLevel } from '@scayle/storefront-core';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
 import 'zod';
 
-declare const _default: _nuxt_schema.NuxtModule<ModuleBaseOptions>;
+declare const _default: _nuxt_schema.NuxtModule<Omit<ModuleBaseOptions, "sapi" | "bapi">>;
 
 export { ModuleBaseOptions, _default as default };

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/storefront-nuxt",
-  "version": "7.81.0",
+  "version": "7.82.2",
   "configKey": "storefront",
   "compatibility": {
     "nuxt": "^3.9.0"

package/dist/module.mjs

@@ -65,7 +65,7 @@ export default {
 }`;
 }
 const PACKAGE_NAME = "@scayle/storefront-nuxt";
-const PACKAGE_VERSION = "7.81.0";
+const PACKAGE_VERSION = "7.82.2";
 const logger = createConsola({
   fancy: true,
   formatOptions: {
@@ -98,10 +98,6 @@ const module = defineNuxtModule({
       // if we set maxAge explicitly to undefined `useRuntimeConfig` will set it default to '' which leads to no sessions not being saved
       // maxAge: undefined,
     },
-    bapi: {
-      host: "",
-      token: ""
-    },
     shopSelector: "domain",
     stores: {},
     oauth: {

package/dist/rpc.d.mts

@@ -1,6 +1,6 @@
 import { RpcMethodName, RpcMethodParameters, RpcMethodReturnType, RpcContext } from '@scayle/storefront-core';
 import { NuxtApp } from 'nuxt/app';
-import { P as PublicShopConfig } from './shared/storefront-nuxt.ed010583.mjs';
+import { P as PublicShopConfig } from './shared/storefront-nuxt.87331293.mjs';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
 import 'zod';

package/dist/rpc.d.ts

@@ -1,6 +1,6 @@
 import { RpcMethodName, RpcMethodParameters, RpcMethodReturnType, RpcContext } from '@scayle/storefront-core';
 import { NuxtApp } from 'nuxt/app';
-import { P as PublicShopConfig } from './shared/storefront-nuxt.ed010583.js';
+import { P as PublicShopConfig } from './shared/storefront-nuxt.87331293.js';
 import '@scayle/unstorage-compression-driver';
 import 'unstorage';
 import 'zod';

package/dist/runtime/campaignKey.d.ts

@@ -3,4 +3,4 @@ export declare const isCampaignActive: (campaign?: Campaign) => boolean;
 export declare const campaignHasNotEnded: (campaign: Campaign) => boolean;
 export declare const campaignKeyMatchesKeyword: (campaign: Campaign, keyword?: string) => boolean;
 export declare const sortCampaignsByDateAscending: (a: Campaign, b: Campaign) => number;
-export declare const fetchCampaignKey: (bapiClient: StorefrontAPIClient, cached: CachedType, storeCampaignKeyword: string | undefined, log: Log) => Promise<string | undefined>;
+export declare const fetchCampaignKey: (sapiClient: StorefrontAPIClient, cached: CachedType, storeCampaignKeyword: string | undefined, log: Log) => Promise<string | undefined>;

package/dist/runtime/campaignKey.mjs

@@ -21,10 +21,10 @@ export const campaignKeyMatchesKeyword = (campaign, keyword) => {
 export const sortCampaignsByDateAscending = (a, b) => {
   return new Date(a.start_at).getTime() - new Date(b.start_at).getTime();
 };
-export const fetchCampaignKey = async (bapiClient, cached, storeCampaignKeyword, log) => {
+export const fetchCampaignKey = async (sapiClient, cached, storeCampaignKeyword, log) => {
   try {
     const { campaigns } = await cached(async () => {
-      const { entities } = await bapiClient.campaigns.get();
+      const { entities } = await sapiClient.campaigns.get();
       return {
         campaigns: entities.filter((campaign) => {
           return campaignHasNotEnded(campaign) && campaignKeyMatchesKeyword(campaign, storeCampaignKeyword);

package/dist/runtime/composables/core/useIDP.d.ts

@@ -1,22 +1,28 @@
 import { type MaybeRefOrGetter } from 'vue';
 import type { RpcMethodParameters } from '@scayle/storefront-core';
-export declare function useIDP(params?: MaybeRefOrGetter<RpcMethodParameters<'getExternalIdpRedirect'>>, key?: string): import("nuxt/dist/app/composables/asyncData")._AsyncData<{
-    [k: string]: string;
-}, any> & {
-    fetching: import("vue").Ref<boolean>;
+export declare function useIDP(params?: MaybeRefOrGetter<RpcMethodParameters<'getExternalIdpRedirect'>>, key?: string): {
+    data: import("vue").Ref<{
+        [k: string]: string;
+    }>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+    fetching: import("vue").Ref<boolean>;
+    error: import("vue").Ref<any>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
     handleIDPLoginCallback: (params: string | {
         code: string;
     }) => Promise<{
         message: string;
     }>;
-} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<{
-    [k: string]: string;
-}, any> & {
-    fetching: import("vue").Ref<boolean>;
+} & Promise<{
+    data: import("vue").Ref<{
+        [k: string]: string;
+    }>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+    fetching: import("vue").Ref<boolean>;
+    error: import("vue").Ref<any>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
     handleIDPLoginCallback: (params: string | {
         code: string;
     }) => Promise<{

package/dist/runtime/composables/core/useIDP.mjs

@@ -12,12 +12,26 @@ export function useIDP(params = {}, key) {
     key ?? "useIDP",
     params
   );
+  const {
+    data,
+    fetch,
+    fetching,
+    error,
+    refresh,
+    status
+  } = useRpcPromise;
   const handleIDPLoginCallback = rpcCall(
     nuxtApp,
     "handleIDPLoginCallback",
     toValue(shop)
   );
-  return extendPromise(useRpcPromise, {
+  return extendPromise(useRpcPromise.then(() => ({})), {
+    data,
+    fetch,
+    fetching,
+    error,
+    refresh,
+    status,
     // TODO: Deprecate the property here and remove it with the next major release
     handleIDPLoginCallback
   });

package/dist/runtime/composables/storefront/useBasket.d.ts

@@ -5,10 +5,7 @@ type UseBasketOptions = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getBasket'>>;
     key: string;
 }>;
-export declare function useBasket({ params, key, }?: UseBasketOptions): import("nuxt/dist/app/composables/asyncData")._AsyncData<BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>, any> & {
-    fetching: import("vue").Ref<boolean>;
-    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+export declare function useBasket({ params, key, }?: UseBasketOptions): {
     data: import("vue").Ref<BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>>;
     items: import("vue").ComputedRef<import("@scayle/storefront-api").BasketItem<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>[]>;
     cost: import("vue").ComputedRef<import("@scayle/storefront-api").BasketTotalPrice>;
@@ -17,7 +14,9 @@ export declare function useBasket({ params, key, }?: UseBasketOptions): import("
     shippingDates: import("vue").ComputedRef<(string | null)[] | undefined>;
     isEmpty: import("vue").ComputedRef<boolean>;
     fetching: import("vue").Ref<boolean>;
+    pending: import("vue").Ref<boolean>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
     count: import("vue").ComputedRef<number>;
     countWithoutSoldOutItems: import("vue").ComputedRef<number>;
     addItem: ({ variantId, promotionId, quantity, existingItemHandling, displayData, customData, itemGroup, }: AddOrUpdateItemType & {
@@ -63,10 +62,7 @@ export declare function useBasket({ params, key, }?: UseBasketOptions): import("
     } | undefined>;
     error: import("vue").Ref<any>;
     status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
-} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>, any> & {
-    fetching: import("vue").Ref<boolean>;
-    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+} & Promise<{
     data: import("vue").Ref<BasketResponseData<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>>;
     items: import("vue").ComputedRef<import("@scayle/storefront-api").BasketItem<import("@scayle/storefront-api").Product, import("@scayle/storefront-api").Variant>[]>;
     cost: import("vue").ComputedRef<import("@scayle/storefront-api").BasketTotalPrice>;
@@ -75,7 +71,9 @@ export declare function useBasket({ params, key, }?: UseBasketOptions): import("
     shippingDates: import("vue").ComputedRef<(string | null)[] | undefined>;
     isEmpty: import("vue").ComputedRef<boolean>;
     fetching: import("vue").Ref<boolean>;
+    pending: import("vue").Ref<boolean>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
     count: import("vue").ComputedRef<number>;
     countWithoutSoldOutItems: import("vue").ComputedRef<number>;
     addItem: ({ variantId, promotionId, quantity, existingItemHandling, displayData, customData, itemGroup, }: AddOrUpdateItemType & {

package/dist/runtime/composables/storefront/useBasket.mjs

@@ -30,9 +30,9 @@ export function useBasket({
   });
   const {
     data,
-    pending: fetching,
+    pending,
     error,
-    refresh: fetch,
+    refresh,
     status
   } = asyncData;
   const addItem = async ({
@@ -159,7 +159,7 @@ export function useBasket({
   const shippingDates = computed(
     () => packages.value ? getShippingDates(packages.value) : void 0
   );
-  return extendPromise(asyncData, {
+  return extendPromise(asyncData.then(() => ({})), {
     data,
     items,
     cost,
@@ -167,8 +167,10 @@ export function useBasket({
     packages,
     shippingDates,
     isEmpty,
-    fetching,
-    fetch,
+    fetching: pending,
+    pending,
+    fetch: refresh,
+    refresh,
     count,
     countWithoutSoldOutItems,
     addItem,

package/dist/runtime/composables/storefront/useCategories.d.ts

@@ -7,27 +7,33 @@ type Options = Partial<{
     /** @deprecated use the second argument of the composable to define the key */
     key: string;
 }>;
-export declare function useCategories({ params, options, key: _key, }?: Options, key?: string): import("nuxt/dist/app/composables/asyncData")._AsyncData<{
-    categories: import("@scayle/storefront-api").Category[];
-    activeNode: undefined;
-} | {
-    categories: import("@scayle/storefront-api").Category;
-    activeNode: import("@scayle/storefront-api").Category;
-}, any> & {
-    fetching: import("vue").Ref<boolean>;
+export declare function useCategories({ params, options, key: _key, }?: Options, key?: string): {
+    data: import("vue").Ref<{
+        categories: import("@scayle/storefront-api").Category[];
+        activeNode: undefined;
+    } | {
+        categories: import("@scayle/storefront-api").Category;
+        activeNode: import("@scayle/storefront-api").Category;
+    }>;
+    error: import("vue").Ref<any>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
-    getCategoryById: (id: number, includeHidden?: true) => Promise<import("@scayle/storefront-api").Category>;
-} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<{
-    categories: import("@scayle/storefront-api").Category[];
-    activeNode: undefined;
-} | {
-    categories: import("@scayle/storefront-api").Category;
-    activeNode: import("@scayle/storefront-api").Category;
-}, any> & {
     fetching: import("vue").Ref<boolean>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    getCategoryById: (id: number, includeHidden?: true) => Promise<import("@scayle/storefront-api").Category>;
+} & Promise<{
+    data: import("vue").Ref<{
+        categories: import("@scayle/storefront-api").Category[];
+        activeNode: undefined;
+    } | {
+        categories: import("@scayle/storefront-api").Category;
+        activeNode: import("@scayle/storefront-api").Category;
+    }>;
+    error: import("vue").Ref<any>;
+    status: import("vue").Ref<import("nuxt/app").AsyncDataRequestStatus>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+    fetching: import("vue").Ref<boolean>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
     getCategoryById: (id: number, includeHidden?: true) => Promise<import("@scayle/storefront-api").Category>;
 }>;
 export {};

package/dist/runtime/composables/storefront/useCategories.mjs

@@ -21,7 +21,21 @@ export function useCategories({
     "getCategoryById",
     currentShop.value ?? void 0
   );
-  return extendPromise(useRpcPromise, {
+  const {
+    data,
+    error,
+    status,
+    fetch,
+    fetching,
+    refresh
+  } = useRpcPromise;
+  return extendPromise(useRpcPromise.then(() => ({})), {
+    data,
+    error,
+    status,
+    fetch,
+    fetching,
+    refresh,
     getCategoryById: (id, includeHidden) => getCategoryById({ id, includeHidden })
   });
 }

package/dist/runtime/composables/storefront/useOrder.d.ts

@@ -1,6 +1,6 @@
 import type { RpcMethodParameters, Order } from '@scayle/storefront-core';
 import type { RpcOptions } from '../core/useRpc';
-import type { MaybeRefOrGetter } from '#imports';
+import type { Ref, MaybeRefOrGetter } from 'vue';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getOrderById'>>;
     options: RpcOptions;
@@ -11,10 +11,7 @@ export declare function useOrder<P = {
     [k: string]: unknown;
 }, V = {
     [k: string]: unknown;
-}>({ params, options, key: _key }?: Options, key?: string): import("nuxt/dist/app/composables/asyncData")._AsyncData<Order, any> & {
-    fetching: import("vue").Ref<boolean>;
-    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+}>({ params, options, key: _key }?: Options, key?: string): {
     data: Ref<Order & {
         items?: ({
             id?: import("@scayle/storefront-core").UniqueNumericIdentifierOfTheItem;
@@ -85,10 +82,12 @@ export declare function useOrder<P = {
             variant: V;
         })[];
     }>;
-} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<Order, any> & {
-    fetching: import("vue").Ref<boolean>;
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+    fetching: Ref<boolean>;
+    error: Ref<any>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    status: Ref<import("nuxt/app").AsyncDataRequestStatus>;
+} & Promise<{
     data: Ref<Order & {
         items?: ({
             id?: import("@scayle/storefront-core").UniqueNumericIdentifierOfTheItem;
@@ -159,5 +158,10 @@ export declare function useOrder<P = {
             variant: V;
         })[];
     }>;
+    fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    fetching: Ref<boolean>;
+    error: Ref<any>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    status: Ref<import("nuxt/app").AsyncDataRequestStatus>;
 }>;
 export {};

package/dist/runtime/composables/storefront/useOrder.mjs

@@ -7,8 +7,21 @@ export function useOrder({ params, options, key: _key } = {}, key) {
     params,
     options
   );
-  const _data = promise.data;
-  return extendPromise(promise, {
-    data: _data
+  const {
+    data,
+    fetch,
+    fetching,
+    error,
+    refresh,
+    status
+  } = promise;
+  const _data = data;
+  return extendPromise(promise.then(() => ({})), {
+    data: _data,
+    fetch,
+    fetching,
+    error,
+    refresh,
+    status
   });
 }

package/dist/runtime/composables/storefront/useOrderConfirmation.d.ts

@@ -1,6 +1,6 @@
 import type { RpcMethodParameters, Order } from '@scayle/storefront-core';
 import type { RpcOptions } from '../core/useRpc';
-import type { MaybeRefOrGetter } from '#imports';
+import type { Ref, MaybeRefOrGetter } from 'vue';
 type Options = Partial<{
     params: MaybeRefOrGetter<RpcMethodParameters<'getOrderDataByCbd'>>;
     options: RpcOptions;
@@ -11,10 +11,12 @@ export declare function useOrderConfirmation<P = {
     [k: string]: unknown;
 }, V = {
     [k: string]: unknown;
-}>({ params, options, key: _key }?: Options, key?: string): import("nuxt/dist/app/composables/asyncData")._AsyncData<Order | undefined, any> & {
-    fetching: import("vue").Ref<boolean>;
+}>({ params, options, key: _key }?: Options, key?: string): {
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+    fetching: Ref<boolean>;
+    error: Ref<any>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    status: Ref<import("nuxt/app").AsyncDataRequestStatus>;
     data: Ref<Order & {
         items?: ({
             id?: import("@scayle/storefront-core").UniqueNumericIdentifierOfTheItem;
@@ -85,10 +87,12 @@ export declare function useOrderConfirmation<P = {
             variant: V;
         })[];
     }>;
-} & Promise<import("nuxt/dist/app/composables/asyncData")._AsyncData<Order | undefined, any> & {
-    fetching: import("vue").Ref<boolean>;
+} & Promise<{
     fetch: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
-} & {
+    fetching: Ref<boolean>;
+    error: Ref<any>;
+    refresh: (opts?: import("nuxt/dist/app/composables/asyncData").AsyncDataExecuteOptions) => Promise<void>;
+    status: Ref<import("nuxt/app").AsyncDataRequestStatus>;
     data: Ref<Order & {
         items?: ({
             id?: import("@scayle/storefront-core").UniqueNumericIdentifierOfTheItem;

package/dist/runtime/composables/storefront/useOrderConfirmation.mjs

@@ -7,8 +7,21 @@ export function useOrderConfirmation({ params, options, key: _key } = {}, key) {
     params,
     options
   );
-  const _data = promise.data;
-  return extendPromise(promise, {
+  const {
+    data,
+    fetch,
+    fetching,
+    error,
+    refresh,
+    status
+  } = promise;
+  const _data = data;
+  return extendPromise(promise.then(() => ({})), {
+    fetch,
+    fetching,
+    error,
+    refresh,
+    status,
     data: _data
   });
 }

package/dist/runtime/context.d.ts

@@ -2,6 +2,7 @@ import type { Session } from '@scayle/h3-session';
 import type { RuntimeConfig } from '@nuxt/schema';
 import { type H3Event } from 'h3';
 import type { Log, RpcContext, Cache as CacheInterface } from '@scayle/storefront-core';
+import { StorefrontAPIClient } from '@scayle/storefront-core';
 import type { ShopConfig, StorefrontConfig } from '../module';
 export interface ContextBuilderOptions {
     $cache: CacheInterface;
@@ -14,3 +15,8 @@ export interface ContextBuilderOptions {
     event: H3Event;
 }
 export declare const buildContext: (context: ContextBuilderOptions) => Promise<RpcContext>;
+declare module '@scayle/storefront-core' {
+    interface AdditionalRpcContext {
+        sapiClient: StorefrontAPIClient;
+    }
+}