@scayle/storefront-nuxt 8.29.0 → 8.30.0

package/CHANGELOG.md

@@ -1,5 +1,48 @@
 # @scayle/storefront-nuxt
 
+## 8.30.0
+
+### Patch Changes
+
+**Dependencies**
+
+**@scayle/storefront-core v8.30.0**
+
+- Minor
+
+  - Added `defineRpcHandler` utility function that enhances RPC handlers with type-safe metadata for improved registration and invocation of RPC handlers. While defining RPC handlers without this utility remains supported, its usage is recommended and may become mandatory in a future major release.
+
+  Existing RPC handlers can be easily migrated to use `defineRpcHandler` by passing the existing handler to `defineRpcHandler`.
+
+  ```ts
+  export const existingHandlerWithoutParams = async (_context: RpcContext) => {
+    return 'existing handler'
+  }
+
+  export const existingHandlerWithParams = async (
+    { name }: { name: string },
+    _context: RpcContext,
+  ) => {
+    return name
+  }
+
+  // will become
+
+  export const existingHandlerWithoutParams = defineRpcHandler(
+    async (_context: RpcContext) => {
+      return 'existing handler'
+    },
+  )
+  export const existingHandlerWithParams = defineRpcHandler(
+    async ({ name }: { name: string }, _context: RpcContext) => {
+      return name
+    },
+  )
+  ```
+
+- Patch
+  - Removed unused `Awaited` and `PromiseReturnType` types.
+
 ## 8.29.0
 
 ### Patch Changes

package/dist/module.json

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

package/dist/module.mjs

@@ -54,7 +54,7 @@ export default {
 }`;
 }
 const PACKAGE_NAME = "@scayle/storefront-nuxt";
-const PACKAGE_VERSION = "8.29.0";
+const PACKAGE_VERSION = "8.30.0";
 const logger = createConsola({
   fancy: true,
   formatOptions: {

package/dist/runtime/handler.d.ts

@@ -19,4 +19,4 @@ import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnTyp
  *
  * @throws {Error} If the specified RPC method is not found.
  */
-export declare const invokeRpc: <N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Awaited<RpcMethodReturnType<N>>, TakesParameters = P extends RpcContext ? undefined : boolean, TParams = TakesParameters extends undefined ? null : P>(method: N, payload: TParams, rpcContext: RpcContext) => Promise<TResult | Response>;
+export declare const invokeRpc: <N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Awaited<RpcMethodReturnType<N>>, TakesParameters = P extends RpcContext ? undefined : boolean, TParams = TakesParameters extends undefined ? null : P>(method: N, payload: TParams, rpcContext: RpcContext) => Promise<TResult>;

package/dist/runtime/handler.js

@@ -1,24 +1,22 @@
 import { rpcMethods as coreRpcMethods } from "@scayle/storefront-core";
 import * as storefrontRpcMethods from "#virtual/customRpcMethods";
-export const invokeRpc = async (method, payload, rpcContext) => {
-  const rpcMethods = {
+import { normalizeRpcHandler } from "./utils/rpc.js";
+const rpcMethods = Object.fromEntries(
+  Object.entries({
     ...coreRpcMethods,
     ...storefrontRpcMethods
-  };
+  }).map(([key, value]) => [key, normalizeRpcHandler(value)])
+);
+export const invokeRpc = async (method, payload, rpcContext) => {
   if (!Object.hasOwn(rpcMethods, method)) {
     throw new Error(`RPC Method [${method}] was not found`);
   }
   const log = rpcContext.log.space("sfc").space("rpc");
+  const handlerFunction = rpcMethods[method];
   return await log.time(`Calling RPC method: ${method}`, async () => {
-    const fun = rpcMethods[method];
-    if (fun.length === 1) {
-      return await fun(
-        rpcContext
-      );
+    if (handlerFunction.rpcType === "NoParam") {
+      return await handlerFunction(rpcContext);
     }
-    return await fun(
-      payload,
-      rpcContext
-    );
+    return await handlerFunction(payload, rpcContext);
   });
 };

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

@@ -0,0 +1,10 @@
+import { type RpcMethods, type RpcMethodName, type 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.
+ *
+ * @param handler - The handler function to normalize.
+ * @returns The normalized handler function with an `rpcType` property.
+ */
+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<P, R> & Required<Pick<RpcHandler<P, R>, "rpcType">> : never>(handler: T) => NormalizedHandler;

package/dist/runtime/utils/rpc.js

@@ -0,0 +1,9 @@
+import {
+  defineRpcHandler
+} from "@scayle/storefront-core";
+export const normalizeRpcHandler = (handler) => {
+  if (handler && !("rpcType" in handler)) {
+    return defineRpcHandler(handler);
+  }
+  return handler;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@scayle/storefront-nuxt",
   "type": "module",
-  "version": "8.29.0",
+  "version": "8.30.0",
   "description": "Nuxt integration for the SCAYLE Commerce Engine and Storefront API",
   "author": "SCAYLE Commerce Engine",
   "license": "MIT",
@@ -81,7 +81,7 @@
   "dependencies": {
     "@opentelemetry/api": "^1.9.0",
     "@scayle/h3-session": "0.6.1",
-    "@scayle/storefront-core": "8.29.0",
+    "@scayle/storefront-core": "8.30.0",
     "@scayle/unstorage-compression-driver": "^1.0.0",
     "@vercel/nft": "0.29.4",
     "@vueuse/core": "13.3.0",
@@ -108,7 +108,7 @@
     "@nuxt/module-builder": "1.0.1",
     "@nuxt/schema": "3.16.2",
     "@nuxt/test-utils": "3.18.0",
-    "@scayle/eslint-config-storefront": "4.5.5",
+    "@scayle/eslint-config-storefront": "4.5.6",
     "@scayle/eslint-plugin-vue-composable": "0.2.1",
     "@scayle/unstorage-scayle-kv-driver": "1.0.1",
     "@types/node": "22.15.32",