@scayle/storefront-nuxt 8.60.1 → 8.61.0

package/dist/module.json

@@ -1,6 +1,6 @@
 {
   "name": "@scayle/storefront-nuxt",
-  "version": "8.60.1",
+  "version": "8.61.0",
   "configKey": "storefront",
   "compatibility": {
     "nuxt": ">=3.13"

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import { existsSync } from 'node:fs';
-import { defineNuxtModule, createResolver, addServerTemplate, addTypeTemplate, extendViteConfig, addPlugin, addImportsDir } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addServerTemplate, addTypeTemplate, extendViteConfig, addTemplate, updateTemplates, addPlugin, addImportsDir } from '@nuxt/kit';
 import { rpcMethods } from '@scayle/storefront-core';
 import { defu } from 'defu';
 import { genExport, genImport, genSafeVariableName } from 'knitwork';
@@ -54,7 +54,7 @@ export default {
 }`;
 }
 const PACKAGE_NAME = "@scayle/storefront-nuxt";
-const PACKAGE_VERSION = "8.60.1";
+const PACKAGE_VERSION = "8.61.0";
 const logger = createConsola({
   fancy: true,
   formatOptions: {
@@ -89,14 +89,70 @@ function createRpcMethodTypeDeclaration(customRpcImports) {
     }
     export {}`;
 }
+const DEFAULT_RPC_HTTP_METHOD = "POST";
+const ALLOWED_RPC_HTTP_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "DELETE"
+]);
+function readHttpMethod(handler) {
+  if (handler && typeof handler === "function" && "httpMethod" in handler && typeof handler.httpMethod === "string") {
+    const method = handler.httpMethod.toUpperCase();
+    if (ALLOWED_RPC_HTTP_METHODS.has(method)) {
+      return method;
+    }
+  }
+  return DEFAULT_RPC_HTTP_METHOD;
+}
+async function buildRpcHttpMethodManifest(customRpcImports, coreHandlers) {
+  const manifest = {};
+  for (const [name, handler] of Object.entries(coreHandlers)) {
+    manifest[name] = readHttpMethod(handler);
+  }
+  if (customRpcImports.length === 0) {
+    return manifest;
+  }
+  for (const { source, names } of customRpcImports) {
+    let loadedModule;
+    try {
+      loadedModule = await import(source);
+    } catch (error) {
+      logger.warn(
+        `Failed to load custom RPC module '${source}' while inferring HTTP methods. Methods from this module will default to '${DEFAULT_RPC_HTTP_METHOD}'.`,
+        error
+      );
+    }
+    for (const name of names) {
+      manifest[name] = loadedModule && name in loadedModule ? readHttpMethod(loadedModule[name]) : DEFAULT_RPC_HTTP_METHOD;
+    }
+  }
+  return manifest;
+}
+function createRpcHttpMethodsSource(manifest) {
+  return `// Auto-generated by @scayle/storefront-nuxt
+export const rpcHttpMethods = ${JSON.stringify(manifest, null, 2)}
+`;
+}
 async function nitroSetup(nitroConfig, config, moduleOptions) {
   const { resolve, resolvePath } = createResolver(import.meta.url);
-  const { apiBasePath, customRpcImports, coreMethodNames, usedDrivers } = config;
+  const {
+    apiBasePath,
+    customRpcImports,
+    coreMethodNames,
+    usedDrivers,
+    rpcHttpMethodManifest,
+    rpcHttpMethodsPath
+  } = config;
   nitroConfig.replace = nitroConfig.replace || {};
   nitroConfig.replace["process.env.SFC_OMIT_MD5"] = stringToBoolean(
     process.env.SFC_OMIT_MD5
   );
   nitroConfig.replace.__sfc_version = PACKAGE_VERSION;
+  nitroConfig.alias = {
+    ...nitroConfig.alias,
+    "#virtual/rpcHttpMethods": rpcHttpMethodsPath
+  };
   nitroConfig.virtual = {
     ...nitroConfig.virtual,
     "#virtual/storage-drivers": createVirtualDriverImport(
@@ -116,10 +172,11 @@ async function nitroSetup(nitroConfig, config, moduleOptions) {
     []
   ).concat(coreMethodNames);
   for (const methodName of allRpcNames) {
+    const httpMethod = rpcHttpMethodManifest[methodName] ?? DEFAULT_RPC_HTTP_METHOD;
     nitroConfig.handlers.push({
       route: `${apiBasePath}/rpc/${methodName}`,
       handler: resolve("./runtime/api/rpcHandler"),
-      method: "post"
+      method: httpMethod.toLowerCase()
     });
   }
   nitroConfig.handlers.push({
@@ -243,7 +300,9 @@ const module$1 = defineNuxtModule({
   },
   async setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
-    const { resolve: appResolve } = createResolver(nuxt.options.rootDir);
+    const { resolve: appResolve, resolvePath } = createResolver(
+      nuxt.options.rootDir
+    );
     addServerTemplate({
       filename: "#internal/storefront-options.mjs",
       getContents: () => `
@@ -326,6 +385,8 @@ const module$1 = defineNuxtModule({
     const rpcMethodNames = new Set(Object.keys(rpcMethods));
     const storefrontRpcMethodNames = options.rpcMethodNames ?? [];
     const customRpcImports = [];
+    let rpcHttpMethodManifest = {};
+    let rpcHttpMethodsPath = "";
     nuxt.hook("modules:done", async () => {
       await nuxt.callHook("storefront:custom-rpc:extend", customRpcImports);
       customRpcImports.forEach((customImport) => {
@@ -340,7 +401,9 @@ const module$1 = defineNuxtModule({
           (name) => !storefrontRpcMethodNames.includes(name)
         );
       });
-      const rpcDir = appResolve(options.rpcDir ?? "./rpcMethods");
+      const rpcDir = await resolvePath(
+        appResolve(options.rpcDir ?? "./rpcMethods")
+      );
       if (existsSync(rpcDir)) {
         customRpcImports.push({
           source: rpcDir,
@@ -355,6 +418,23 @@ const module$1 = defineNuxtModule({
         ),
         rpcMethodNames
       );
+      rpcHttpMethodManifest = await buildRpcHttpMethodManifest(
+        customRpcImports,
+        rpcMethods
+      );
+      const rpcHttpMethodsSource = createRpcHttpMethodsSource(
+        rpcHttpMethodManifest
+      );
+      const rpcHttpMethodsTemplate = addTemplate({
+        filename: "rpc-http-methods.mjs",
+        write: true,
+        getContents: () => rpcHttpMethodsSource
+      });
+      rpcHttpMethodsPath = rpcHttpMethodsTemplate.dst;
+      nuxt.options.alias["#virtual/rpcHttpMethods"] = rpcHttpMethodsPath;
+      await updateTemplates({
+        filter: (template) => template.filename === "rpc-http-methods.mjs"
+      });
       addTypeTemplate({
         filename: "types/storefront-custom-rpc.d.ts",
         getContents: () => createRpcMethodTypeDeclaration(customRpcImports)
@@ -385,7 +465,9 @@ const module$1 = defineNuxtModule({
         apiBasePath,
         customRpcImports,
         coreMethodNames: [...rpcMethodNames],
-        usedDrivers: getUsedDrivers(nuxt.options.runtimeConfig.storefront)
+        usedDrivers: getUsedDrivers(nuxt.options.runtimeConfig.storefront),
+        rpcHttpMethodManifest,
+        rpcHttpMethodsPath
       }, nuxt.options.runtimeConfig.storefront);
     });
     nuxt.hooks.hook("nitro:init", async (nitro) => {
@@ -451,6 +533,7 @@ const module$1 = defineNuxtModule({
     nuxt.options.optimization.keyedComposables.push(
       ...keyedComposables.map((name) => ({
         name,
+        source: "@scayle/storefront-nuxt",
         argumentLength: 2
       }))
     );

package/dist/runtime/api/rpcHandler.d.ts

@@ -1,8 +1,15 @@
 /**
  * Generic event handler for RPC methods.
  *
- * It retrieves the RPC method name from the request path,
- * reads the payload from the request body.
+ * Retrieves the RPC method name from the request path and extracts the payload:
+ * - For `POST` / `PUT` / `DELETE`, the payload is read from the JSON
+ *   request body as `{ payload: ... }` (compatible with the RPC client).
+ * - For `GET`, expects a JSON-serialized payload in a single query field `payload`.
+ *   If present, the handler parses the string using `JSON.parse(payload)`.
+ *   If `payload` is missing the RPC receives `undefined`.
+ *   A non-string `payload` value (e.g. repeated keys producing an array) or invalid
+ *   JSON results in a `400` error response.
+ *
  * It utilizes hooks provided by Nitro to allow for custom logic before,
  * after, and in case of errors during RPC calls.
  *
@@ -10,7 +17,7 @@
  *
  * @returns The result of the RPC call or a `Response` object with an error status.
  */
-declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | boolean | void | string[] | import("@scayle/storefront-api").Campaign | Record<string, unknown> | import("@scayle/storefront-core").ShopUser | Response | import("@scayle/storefront-api").Product | import("@scayle/storefront-api").Product[] | import("@scayle/storefront-core").FetchProductsCountResponse | import("@scayle/storefront-core").FetchFiltersResponse | import("@scayle/storefront-core").FetchProductsByCategoryResponse | {
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string | boolean | void | string[] | import("@scayle/storefront-api").Campaign | Record<string, unknown> | import("@scayle/storefront-core").ShopUser | import("@scayle/storefront-api").Product | import("@scayle/storefront-api").Product[] | import("@scayle/storefront-core").FetchProductsCountResponse | import("@scayle/storefront-core").FetchFiltersResponse | import("@scayle/storefront-core").FetchProductsByCategoryResponse | {
     success: boolean;
 } | {
     result: boolean;
@@ -41,7 +48,7 @@ declare const _default: import("h3").EventHandler<import("h3").EventHandlerReque
     type: undefined;
 } | import("@scayle/storefront-api").ShopConfiguration | {
     user?: import("@scayle/storefront-core").ShopUser;
-} | import("@scayle/storefront-api").Wishlist | import("@scayle/storefront-core").ShopUserAddress[] | {
+} | import("@scayle/storefront-api").Wishlist | Response | import("@scayle/storefront-core").ShopUserAddress[] | {
     accessToken: string | undefined;
     checkoutJwt: string;
 } | import("@scayle/storefront-api").VariantDetail[] | import("@scayle/storefront-api").NavigationAllEndpointResponseData | import("@scayle/storefront-api").NavigationTree | import("@scayle/storefront-api").PromotionsEndpointResponseData | {

package/dist/runtime/api/rpcHandler.js

@@ -1,9 +1,21 @@
-import { defineEventHandler, readBody, createError, getRequestURL } from "h3";
-import { purifySensitiveData, HttpStatusCode } from "@scayle/storefront-core";
+import {
+  defineEventHandler,
+  readBody,
+  createError,
+  getQuery,
+  getRequestURL,
+  appendResponseHeader
+} from "h3";
+import {
+  HttpStatusCode,
+  purifySensitiveData,
+  DEFAULT_RPC_HTTP_METHOD
+} from "@scayle/storefront-core";
 import { trace, SpanStatusCode } from "@opentelemetry/api";
 import { invokeRpc } from "../handler.js";
 import { resolveError } from "../error/handler.js";
 import { useNitroApp } from "nitropack/runtime";
+import { rpcHttpMethods } from "#virtual/rpcHttpMethods";
 export default defineEventHandler(async (event) => {
   const $rpcContext = event.context.$rpcContext;
   if (!$rpcContext) {
@@ -17,18 +29,44 @@ export default defineEventHandler(async (event) => {
   );
   const pathComponents = event.path.split("?")[0].split("/");
   const method = pathComponents[pathComponents.length - 1];
-  const body = await readBody(event);
+  const httpMethod = rpcHttpMethods[method] ?? DEFAULT_RPC_HTTP_METHOD;
+  const isGetMethod = httpMethod === "GET";
+  let payload;
+  if (isGetMethod) {
+    const query = getQuery(event);
+    const rawPayload = query.payload;
+    if (rawPayload !== void 0) {
+      if (typeof rawPayload !== "string") {
+        throw createError({
+          statusCode: 400,
+          statusMessage: "Invalid payload: expected a single query parameter"
+        });
+      }
+      try {
+        payload = JSON.parse(rawPayload);
+      } catch {
+        throw createError({
+          statusCode: 400,
+          statusMessage: "Invalid payload: malformed JSON"
+        });
+      }
+    }
+  } else {
+    const body = await readBody(event);
+    payload = body?.payload;
+  }
   const url = getRequestURL(event, {
     xForwardedHost: true,
     xForwardedProto: true
   });
   const payloadToBeLogged = JSON.stringify(
     purifySensitiveData(
-      typeof body?.payload !== "object" ? { [typeof body?.payload]: body?.payload } : body?.payload
+      typeof payload !== "object" || payload === null ? { [typeof payload]: payload } : payload
     )
   );
   $rpcContext.log.space("sfc").debug(`RPC Handler: ${method}, Payload: ${payloadToBeLogged}`);
   const nitroApp = useNitroApp();
+  appendResponseHeader(event, "Vary", "x-shop-id");
   return await tracer.startActiveSpan(
     `storefront-nuxt.rpc/${method}`,
     {
@@ -37,6 +75,8 @@ export default defineEventHandler(async (event) => {
         "rpc.method": method,
         "rpc.service": "storefront-nuxt.rpc",
         "rpc.payload": payloadToBeLogged,
+        // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#http-server
+        "http.method": httpMethod,
         "server.address": url.hostname,
         "server.port": url.port
       }
@@ -48,9 +88,9 @@ export default defineEventHandler(async (event) => {
           "storefront:rpc:before",
           method,
           $rpcContext,
-          body?.payload
+          payload
         );
-        result = await invokeRpc(method, body?.payload, $rpcContext);
+        result = await invokeRpc(method, payload, $rpcContext);
         await nitroApp.hooks.callHook(
           "storefront:rpc:after",
           method,

package/dist/runtime/composables/core/useRpc.js

@@ -1,8 +1,9 @@
-import { unwrap } from "@scayle/storefront-core";
+import { unwrap, DEFAULT_RPC_HTTP_METHOD } from "@scayle/storefront-core";
 import { useAsyncData, useRuntimeConfig, useNuxtApp } from "nuxt/app";
 import { useCoreLog } from "../useCoreLog.js";
 import { useCurrentShop } from "./useCurrentShop.js";
 import { toValue, isRef } from "vue";
+import { rpcHttpMethods as rpcHttpMethodManifest } from "#virtual/rpcHttpMethods";
 function getFetch(nuxtApp, log) {
   const fetch = nuxtApp.ssrContext?.event.context.$fetchWithContext ?? $fetch;
   if (nuxtApp.ssrContext?.event && !nuxtApp.ssrContext?.event.context.$fetchWithContext) {
@@ -28,18 +29,30 @@ export function useRpc(method, key, params, options) {
     async () => {
       const apiBasePath = currentShop.value?.apiBasePath ?? "/api";
       const fetch = getFetch(nuxtApp, log);
-      return await unwrap(
-        await fetch(`/rpc/${method}`, {
-          // @ts-expect-error Type '"POST"' is not assignable to type 'AvailableRouterMethod<`/rpc/${N}`> | Uppercase<AvailableRouterMethod<`/rpc/${N}`>> | undefined'.ts(2322)
-          method: "POST",
-          body: {
-            payload: toValue(params)
-          },
+      const httpMethod = rpcHttpMethodManifest[method] ?? DEFAULT_RPC_HTTP_METHOD;
+      const resolvedParams = toValue(params);
+      const headers = {
+        "x-shop-id": `${currentShop.value?.shopId}`
+      };
+      const path = `/rpc/${method}`;
+      let fetchOptions;
+      if (httpMethod === "GET") {
+        fetchOptions = {
+          method: httpMethod,
+          baseURL: apiBasePath,
+          headers,
+          params: resolvedParams !== void 0 && resolvedParams !== null ? { payload: JSON.stringify(resolvedParams) } : void 0
+        };
+      } else {
+        fetchOptions = {
+          method: httpMethod,
+          body: { payload: resolvedParams },
           baseURL: apiBasePath,
-          headers: {
-            "x-shop-id": `${currentShop.value?.shopId}`
-          }
-        })
+          headers
+        };
+      }
+      return await unwrap(
+        await fetch(path, fetchOptions)
       );
     },
     {

package/dist/runtime/context.js

@@ -4,13 +4,15 @@ import {
   StorefrontAPIClient,
   unwrap,
   generateBasketKey,
-  generateWishlistKey
+  generateWishlistKey,
+  DEFAULT_RPC_HTTP_METHOD
 } from "@scayle/storefront-core";
 import { useNitroApp } from "nitropack/runtime";
 import { getCachedFunction } from "./cached.js";
 import { getApiBasePath } from "./server/middleware/bootstrap-utils.js";
 import { fetchCampaignKey } from "./campaignKey.js";
 import * as moduleOptions from "#internal/storefront-options.mjs";
+import { rpcHttpMethods } from "#virtual/rpcHttpMethods";
 async function getWishlistKey(appKeys, session, $log, $shopConfig) {
   return session.data.user ? await generateWishlistKey({
     keyTemplate: appKeys.wishlistKey,
@@ -32,11 +34,17 @@ async function getBasketKey(appKeys, session, $log, $shopConfig) {
 function buildRpcCall(event, shopConfig, apiBasePath) {
   const fetch = event.context.$fetchWithContext;
   return async function rpcCall(method, params = void 0) {
+    const httpMethod = rpcHttpMethods[method] ?? DEFAULT_RPC_HTTP_METHOD;
+    const isGet = httpMethod === "GET";
     const data = await fetch(`${apiBasePath}/rpc/${method}`, {
-      // @ts-expect-error Type '"POST"' is not assignable to type 'AvailableRouterMethod<`${string}/rpc/${N}`> | Uppercase<AvailableRouterMethod<`${string}/rpc/${N}`>> | undefined'.ts(2322)
-      method: "POST",
-      body: {
-        payload: params
+      // @ts-expect-error Type 'RpcHttpMethod' is not assignable to type 'AvailableRouterMethod<...>'
+      method: httpMethod,
+      ...isGet ? {
+        query: params !== void 0 ? { payload: JSON.stringify(params) } : void 0
+      } : {
+        body: {
+          payload: params
+        }
       },
       headers: {
         "x-shop-id": shopConfig.shopId.toString()

package/dist/runtime/nitro/plugins/nitroStorageConfig.js

@@ -48,7 +48,10 @@ export default defineNitroPlugin(async () => {
     }
   };
   for (const shop of Object.values(shops)) {
-    await mountShopStorage(shop.shopId, `${STORAGE_MOUNT_CACHE}:${shop.shopId}`);
+    await mountShopStorage(
+      shop.shopId,
+      `${STORAGE_MOUNT_CACHE}:${shop.shopId}`
+    );
     await mountShopStorage(
       shop.shopId,
       `${STORAGE_MOUNT_SESSION}:${shop.shopId}`

package/dist/runtime/rpc/rpcCall.d.ts

@@ -5,6 +5,9 @@ import type { PublicShopConfig } from '../types/module.js';
  * Invokes an RPC method on the client or server.
  * Uses an HTTP request on the client and a direct call on the server via `$fetch`.
  *
+ * The HTTP verb is read from the build-time manifest `#virtual/rpcHttpMethods`,
+ * from each `defineRpcHandler`; `POST` when not listed.
+ *
  * @see https://nuxt.com/docs/api/utils/dollarfetch
  *
  * @template N The RPC method name.

package/dist/runtime/rpc/rpcCall.js

@@ -1,17 +1,41 @@
-import { unwrap } from "@scayle/storefront-core";
+import { unwrap, DEFAULT_RPC_HTTP_METHOD } from "@scayle/storefront-core";
+import { rpcHttpMethods } from "#virtual/rpcHttpMethods";
+const buildRequest = (method, params, apiBasePath, shopId, rpcHttpMethods2) => {
+  const httpMethod = rpcHttpMethods2[method] ?? DEFAULT_RPC_HTTP_METHOD;
+  const headers = {
+    "x-shop-id": shopId.toString()
+  };
+  if (httpMethod === "GET") {
+    return {
+      path: `${apiBasePath}/rpc/${method}`,
+      options: {
+        method: httpMethod,
+        headers,
+        params: params !== void 0 && params !== null ? { payload: JSON.stringify(params) } : void 0
+      }
+    };
+  }
+  return {
+    path: `${apiBasePath}/rpc/${method}`,
+    options: {
+      method: httpMethod,
+      body: { payload: params },
+      headers
+    }
+  };
+};
 export const rpcCall = (nuxtApp, method, shop) => {
   const fetch = nuxtApp.ssrContext?.event.context.$fetchWithContext ?? $fetch;
   return async (params = void 0) => {
-    const data = await fetch(`${shop.apiBasePath ?? "/api"}/rpc/${method}`, {
-      // @ts-expect-error Type '"POST"' is not assignable to type 'AvailableRouterMethod<`${string}/rpc/${N}`> | Uppercase<AvailableRouterMethod<`${string}/rpc/${N}`>> | undefined'.ts(2322)
-      method: "POST",
-      body: {
-        payload: params
-      },
-      headers: {
-        "x-shop-id": shop.shopId.toString()
-      }
-    });
+    const apiBasePath = shop.apiBasePath ?? "/api";
+    const { path, options } = buildRequest(
+      method,
+      params,
+      apiBasePath,
+      shop.shopId,
+      rpcHttpMethods
+    );
+    const data = await fetch(path, options);
     return await unwrap(data);
   };
 };

package/dist/runtime/utils/rpc.d.ts

@@ -1,10 +1,11 @@
 import type { RpcMethods, RpcMethodName, RpcHandler } from '@scayle/storefront-core';
 /**
- * Normalizes a rpc handler function that are not defined with `defineRpcHandler`.
- * Normalization sets the `rpcType` property to `WithParam` or `NoParam` based on the number of parameters the handler function takes.
- * Handlers that already have this property set are returned without modification.
+ * Normalizes a rpc handler function that is not defined with `defineRpcHandler`.
+ * Sets the `rpcType` property to `WithParam` or `NoParam` based on the number of parameters
+ * the handler function takes, and defaults `httpMethod` to `'POST'` when it is missing.
+ * Handlers that already have both properties set are returned without modification.
  *
  * @param handler - The handler function to normalize.
- * @returns The normalized handler function with an `rpcType` property.
+ * @returns The normalized handler function with `rpcType` and `httpMethod` properties.
  */
-export declare const normalizeRpcHandler: <T extends RpcMethods[RpcMethodName], NormalizedHandler = T extends RpcHandler<infer R> ? RpcHandler<R> & Required<Pick<RpcHandler<R>, "rpcType">> : T extends RpcHandler<infer _P, infer R> ? RpcHandler<unknown, R> & Required<Pick<RpcHandler<unknown, R>, "rpcType">> : never>(handler: T) => NormalizedHandler;
+export declare const normalizeRpcHandler: <T extends RpcMethods[RpcMethodName], NormalizedHandler = T extends RpcHandler<infer R> ? RpcHandler<R> & Required<Pick<RpcHandler<R>, "rpcType" | "httpMethod">> : T extends RpcHandler<infer _P, infer R> ? RpcHandler<unknown, R> & Required<Pick<RpcHandler<unknown, R>, "rpcType" | "httpMethod">> : never>(handler: T) => NormalizedHandler;

package/dist/runtime/utils/rpc.js

@@ -1,7 +1,17 @@
-import { defineRpcHandler } from "@scayle/storefront-core";
+import {
+  defineRpcHandler,
+  DEFAULT_RPC_HTTP_METHOD
+} from "@scayle/storefront-core";
 export const normalizeRpcHandler = (handler) => {
-  if (handler && !("rpcType" in handler)) {
-    return defineRpcHandler(handler);
+  if (!handler) {
+    return handler;
   }
-  return handler;
+  let normalized = handler;
+  if (!("rpcType" in handler)) {
+    normalized = defineRpcHandler(handler);
+  }
+  if (!("httpMethod" in normalized) || !normalized.httpMethod) {
+    Object.assign(normalized, { httpMethod: DEFAULT_RPC_HTTP_METHOD });
+  }
+  return normalized;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scayle/storefront-nuxt",
   "type": "module",
-  "version": "8.60.1",
+  "version": "8.61.0",
   "description": "Nuxt integration for the SCAYLE Commerce Engine and Storefront API",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -48,7 +48,11 @@
     }
   },
   "imports": {
-    "#storefront/composables": "./dist/runtime/composables/index.js"
+    "#storefront/composables": "./dist/runtime/composables/index.js",
+    "#virtual/rpcHttpMethods": {
+      "types": "./src/stub/rpc-http-methods.d.mts",
+      "default": "./src/stub/rpc-http-methods.mjs"
+    }
   },
   "main": "./dist/index.mjs",
   "files": [
@@ -56,7 +60,8 @@
     "CHANGELOG-V7.md",
     "LICENSE",
     "README.md",
-    "dist"
+    "dist",
+    "src/stub"
   ],
   "engines": {
     "node": ">= 22.0.0"
@@ -72,7 +77,8 @@
     "vue": "^3.4.0"
   },
   "dependencies": {
-    "@opentelemetry/api": "1.9.0",
+    "@opentelemetry/api": "^1.9.0",
+    "@scayle/unstorage-compression-driver": "1.4.0",
     "@vercel/nft": "1.4.0",
     "@vueuse/core": "14.2.1",
     "consola": "^3.4.2",
@@ -90,8 +96,7 @@
     "vue-router": "^4.4.0",
     "zod": "^4.0.0",
     "@scayle/h3-session": "0.7.0",
-    "@scayle/storefront-core": "8.60.1",
-    "@scayle/unstorage-compression-driver": "1.4.0"
+    "@scayle/storefront-core": "8.61.0"
   },
   "devDependencies": {
     "@arethetypeswrong/cli": "0.18.2",
@@ -101,14 +106,16 @@
     "@nuxt/module-builder": "1.0.2",
     "@nuxt/schema": "^3.20.2",
     "@nuxt/test-utils": "4.0.0",
+    "@scayle/eslint-config-storefront": "^4.8.0",
+    "@scayle/eslint-plugin-vue-composable": "^1.1.0",
+    "@scayle/unstorage-scayle-kv-driver": "^2.1.0",
     "@types/node": "22.19.17",
-    "@vitest/coverage-v8": "4.1.2",
-    "dprint": "0.53.2",
-    "eslint": "10.2.0",
-    "eslint-formatter-gitlab": "7.0.1",
+    "@vitest/coverage-v8": "4.1.5",
+    "eslint": "10.2.1",
+    "eslint-formatter-gitlab": "7.1.0",
     "fishery": "2.4.0",
-    "h3": "1.15.10",
-    "happy-dom": "20.8.9",
+    "h3": "1.15.11",
+    "happy-dom": "20.9.0",
     "nitro-test-utils": "0.11.2",
     "nitropack": "2.13.3",
     "node-mocks-http": "1.17.2",
@@ -116,11 +123,8 @@
     "publint": "0.3.18",
     "typescript": "5.9.3",
     "unbuild": "3.6.1",
-    "vitest": "4.1.2",
+    "vitest": "4.1.5",
     "vue-tsc": "3.2.6",
-    "@scayle/eslint-plugin-vue-composable": "1.1.0",
-    "@scayle/eslint-config-storefront": "4.8.0",
-    "@scayle/unstorage-scayle-kv-driver": "2.1.1",
     "@scayle/vitest-config-storefront": "1.0.0"
   },
   "scripts": {
@@ -128,16 +132,11 @@
     "dev": "nuxt dev playground",
     "dev:build": "nuxt build playground",
     "prep": "nuxt-module-build prepare && nuxt prepare playground",
-    "format": "dprint check",
-    "format:fix": "dprint fmt",
     "lint": "eslint .",
     "lint:ci": "eslint . --format gitlab",
     "lint:fix": "eslint . --fix",
     "typecheck": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
     "package:lint": "publint",
-    "verify-packaging": "attw --pack . --profile esm-only",
-    "test": "vitest run",
-    "test:ci": "vitest --run --coverage --reporter=default --reporter=junit --outputFile=./coverage/junit.xml",
-    "test:watch": "vitest watch"
+    "verify-packaging": "attw --pack . --profile esm-only"
   }
 }

package/src/stub/rpc-http-methods.d.mts

@@ -0,0 +1,11 @@
+import type { RpcHttpMethod } from '@scayle/storefront-core'
+
+/**
+ * Type surface for `#virtual/rpcHttpMethods`.
+ *
+ * At build time the consuming Nuxt app replaces this with a generated manifest.
+ * The fallback implementation lives in {@link ./rpc-http-methods.mjs}.
+ */
+declare module '#virtual/rpcHttpMethods' {
+  export const rpcHttpMethods: Record<string, RpcHttpMethod>
+}

package/src/stub/rpc-http-methods.mjs

@@ -0,0 +1,12 @@
+/**
+ * Node / jiti fallback for `#virtual/rpcHttpMethods`.
+ *
+ * The real manifest is generated by the Nuxt module at app build time. Vite and
+ * Nitro aliases override this import during a normal Nuxt build. This file exists
+ * so `package.json#imports` can satisfy Node's ESM resolver when config-time code
+ * loads compiled runtime entry points before Nuxt has installed its aliases
+ * (for example when `jiti` loads the package during Nuxt bootstrap).
+ *
+ * An empty object is safe: callers treat missing keys as `POST`.
+ */
+export const rpcHttpMethods = {}