@scayle/storefront-nuxt 7.36.3

package/dist/module.d.mts

@@ -0,0 +1,8 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { M as ModuleOptions } from './shared/storefront-nuxt.9548700f.mjs';
+export { e as AdditionalShopConfig, A as AppKeys, d as AuthenticationConfig, B as BapiConfig, b as CacheConfig, i as CheckoutEvent, C as CheckoutShopConfig, O as OauthConfig, P as PublicShopConfig, c as RedirectsConfig, R as RedisConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.9548700f.mjs';
+import '@scayle/storefront-core';
+
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { ModuleOptions, _default as default };

package/dist/module.d.ts

@@ -0,0 +1,8 @@
+import * as _nuxt_schema from '@nuxt/schema';
+import { M as ModuleOptions } from './shared/storefront-nuxt.9548700f.js';
+export { e as AdditionalShopConfig, A as AppKeys, d as AuthenticationConfig, B as BapiConfig, b as CacheConfig, i as CheckoutEvent, C as CheckoutShopConfig, O as OauthConfig, P as PublicShopConfig, c as RedirectsConfig, R as RedisConfig, a as SessionConfig, f as ShopConfig, g as ShopConfigIndexed, S as StorageProvider, h as StorefrontConfig } from './shared/storefront-nuxt.9548700f.js';
+import '@scayle/storefront-core';
+
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { ModuleOptions, _default as default };

package/dist/module.json

@@ -0,0 +1,8 @@
+{
+  "name": "@scayle/storefront-nuxt",
+  "configKey": "storefront",
+  "compatibility": {
+    "nuxt": "^3.7.0"
+  },
+  "version": "7.36.2"
+}

package/dist/module.mjs

@@ -0,0 +1,173 @@
+import { defineNuxtModule, createResolver, extendViteConfig, addServerHandler, addTypeTemplate, addPlugin, addImportsDir } from '@nuxt/kit';
+import yn from 'yn';
+import { rpcMethods } from '@scayle/storefront-core';
+import { defu } from 'defu';
+
+const module = defineNuxtModule({
+  meta: {
+    name: "@scayle/storefront-nuxt",
+    configKey: "storefront",
+    compatibility: {
+      nuxt: "^3.7.0"
+    }
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {
+    // TODO: Nuxt is making us give a default for each options
+    // How do we mark some as required?
+    session: {
+      cookieName: "$session",
+      sameSite: "none"
+      // TODO: If we give a default value here, nuxt will generate the runtime type incorrectly
+      // secret needs to be typed as string | string[]
+      // secret: 'current-secret',
+      // 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: "https://bapi.scayle.cloud/",
+      token: ""
+    },
+    redis: {
+      port: 6379,
+      host: "localhost"
+    },
+    shopSelector: "domain",
+    stores: {},
+    log: {
+      name: ""
+    },
+    auth: {
+      redirect: {
+        home: "/",
+        logout: "/"
+      }
+    },
+    oauth: {
+      apiHost: "",
+      clientId: "",
+      clientSecret: ""
+    },
+    appKeys: {
+      wishlistKey: "wishlist_{shopId}_{userId}",
+      basketKey: "basket_{shopId}_{userId}",
+      hashAlgorithm: "sha256"
+    }
+  },
+  setup(options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    const { resolve: appResolve } = createResolver(nuxt.options.srcDir);
+    nuxt.options.runtimeConfig.storefront = defu(
+      nuxt.options.runtimeConfig.storefront,
+      options
+    );
+    nuxt.options.runtimeConfig.cache = {
+      auth: options.cache?.auth
+    };
+    nuxt.options.runtimeConfig.public.publicShopData = options.publicShopData;
+    nuxt.options.runtimeConfig.public.log = options.log;
+    nuxt.options.runtimeConfig.public.auth = options.auth;
+    extendViteConfig((config) => {
+      config.optimizeDeps = config.optimizeDeps || {};
+      config.optimizeDeps.include = config.optimizeDeps.include || [];
+      config.optimizeDeps.include.push(
+        "@scayle/storefront-nuxt",
+        "@scayle/storefront-core",
+        "@aboutyou/backbone",
+        "isomorphic-dompurify",
+        "slugify"
+      );
+    });
+    addServerHandler({
+      middleware: true,
+      handler: resolve("./runtime/server/middleware/bootstrap")
+    });
+    const apiBasePath = nuxt.options.runtimeConfig.storefront.apiBasePath || "/api";
+    addServerHandler({
+      route: `${apiBasePath}/purge/all`,
+      handler: resolve("./runtime/api/purgeAll"),
+      method: "post"
+    });
+    addServerHandler({
+      route: `${apiBasePath}/purge/tags`,
+      handler: resolve("./runtime/api/purgeTags"),
+      method: "post"
+    });
+    addServerHandler({
+      route: `${apiBasePath}/up`,
+      handler: resolve("./runtime/api/up"),
+      method: "get"
+    });
+    const template = addTypeTemplate({
+      filename: "types/storefront-bootstrap.d.ts",
+      getContents: () => `// Auto-generated
+        import type { RpcContext, Cache } from '@scayle/storefront-core'
+        import type { PublicShopConfig } from '@scayle/storefront-nuxt';
+        declare module 'h3' {
+          interface H3EventContext {
+            $rpcContext: RpcContext,
+            $cache: Cache
+            $currentShop: PublicShopConfig,
+            $availableShops: PublicShopConfig[]
+          }
+        }
+        export {}`
+    });
+    nuxt.hook("prepare:types", ({ references }) => {
+      references.push({ path: template.dst });
+    });
+    const rpcMethodNames = /* @__PURE__ */ new Set([
+      ...Object.keys(rpcMethods),
+      ...options.rpcMethodNames ?? []
+    ]);
+    rpcMethodNames.forEach((methodName) => {
+      addServerHandler({
+        route: `${apiBasePath}/rpc/${methodName}`,
+        handler: resolve("./runtime/api/rpcHandler"),
+        method: "post"
+      });
+    });
+    nuxt.hooks.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.externals = nitroConfig.externals || {};
+      nitroConfig.externals.inline = nitroConfig.externals.inline || [];
+      const runtimePaths = [
+        "handler",
+        "error/handler",
+        "context",
+        "createLog",
+        "log",
+        "api/cacheAuth",
+        "rpc/rpcCall",
+        "rpc/rpcRequest",
+        "server/middleware/oauth",
+        "server/middleware/redirects",
+        "server/middleware/cache"
+      ];
+      runtimePaths.forEach((path) => {
+        const file = resolve(`./runtime/${path}`);
+        nitroConfig.externals?.inline?.push(file);
+      });
+      nitroConfig.replace = nitroConfig.replace || {};
+      nitroConfig.replace["process.env.SFC_OMIT_MD5"] = yn(
+        process.env.SFC_OMIT_MD5
+      );
+    });
+    nuxt.options.alias["#rpcMethods"] = appResolve(
+      options.rpcDir ?? "./rpcMethods"
+    );
+    addPlugin(resolve("./runtime/plugin/shop"));
+    addPlugin({
+      src: resolve("./runtime/plugin/log.client"),
+      mode: "client"
+    });
+    addPlugin({
+      src: resolve("./runtime/plugin/log.server"),
+      mode: "server"
+    });
+    addImportsDir(resolve("runtime/composables/storefront"));
+    addImportsDir(resolve("runtime/composables/core"));
+    addImportsDir(resolve("runtime/utils"));
+  }
+});
+
+export { module as default };

package/dist/rpc.d.mts

@@ -0,0 +1,12 @@
+import { RpcMethodName, RpcMethodParameters, RpcMethodReturnType, RpcContext } from '@scayle/storefront-core';
+import { NuxtApp } from 'nuxt/app';
+import { P as PublicShopConfig } from './shared/storefront-nuxt.9548700f.mjs';
+
+/**
+ * rpcCall can be used to invoke an RPC method either on the client or server
+ * It makes an HTTP request on the client and direct call on the server using $fetch
+ * https://nuxt.com/docs/api/utils/dollarfetch
+ */
+declare const rpcCall: <N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Awaited<RpcMethodReturnType<N>>, TakesParameters = P extends RpcContext ? undefined : boolean>(nuxtApp: NuxtApp, method: N, shop: PublicShopConfig) => TakesParameters extends undefined ? () => Promise<TResult> : (params: P) => Promise<TResult>;
+
+export { rpcCall };

package/dist/rpc.d.ts

@@ -0,0 +1,12 @@
+import { RpcMethodName, RpcMethodParameters, RpcMethodReturnType, RpcContext } from '@scayle/storefront-core';
+import { NuxtApp } from 'nuxt/app';
+import { P as PublicShopConfig } from './shared/storefront-nuxt.9548700f.js';
+
+/**
+ * rpcCall can be used to invoke an RPC method either on the client or server
+ * It makes an HTTP request on the client and direct call on the server using $fetch
+ * https://nuxt.com/docs/api/utils/dollarfetch
+ */
+declare const rpcCall: <N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Awaited<RpcMethodReturnType<N>>, TakesParameters = P extends RpcContext ? undefined : boolean>(nuxtApp: NuxtApp, method: N, shop: PublicShopConfig) => TakesParameters extends undefined ? () => Promise<TResult> : (params: P) => Promise<TResult>;
+
+export { rpcCall };

package/dist/rpc.mjs

@@ -0,0 +1,18 @@
+const rpcCall = (nuxtApp, method, shop) => {
+  const fetch = nuxtApp.ssrContext?.event.$fetch ?? $fetch;
+  return async (params = void 0) => {
+    const data = await fetch(`${shop.apiBasePath ?? "/api"}/rpc/${method}`, {
+      // @ts-ignore
+      method: "POST",
+      body: {
+        payload: params
+      },
+      headers: {
+        "x-shop-id": shop.shopId + ""
+      }
+    });
+    return data;
+  };
+};
+
+export { rpcCall };

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

@@ -0,0 +1,12 @@
+import { EventHandler } from 'h3';
+/**
+ * Wrap an event handler protected by the authentication specified in cache.auth
+ * @param handler
+ */
+export declare const eventHandlerWithCacheAuth: (handler: EventHandler) => EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+/**
+ * Wrap an event handler with basic auth
+ * @param handler
+ * @param auth
+ */
+export declare const eventHandlerWithBasicAuth: (handler: EventHandler, auth: string) => EventHandler<import("h3").EventHandlerRequest, Promise<any>>;

package/dist/runtime/api/cacheAuth.mjs

@@ -0,0 +1,40 @@
+import {
+  getRequestHeaders,
+  defineEventHandler,
+  setResponseStatus,
+  setResponseHeader
+} from "h3";
+import { HttpStatusCode } from "@scayle/storefront-core";
+import { useRuntimeConfig } from "#imports";
+export const eventHandlerWithCacheAuth = (handler) => defineEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  const auth = config.cache.auth;
+  if (!auth) {
+    return await handler(event);
+  }
+  return await eventHandlerWithBasicAuth(
+    handler,
+    `${auth.username}:${auth.password}`
+  )(event);
+});
+export const eventHandlerWithBasicAuth = (handler, auth) => defineEventHandler(async (event) => {
+  const headers = getRequestHeaders(event);
+  const authenticationFailed = () => {
+    setResponseHeader(
+      event,
+      "WWW-Authenticate",
+      'Basic realm="Authentication required"'
+    );
+    setResponseStatus(event, HttpStatusCode.UNAUTHORIZED);
+    return "Authentication required";
+  };
+  if (!headers.authorization) {
+    return authenticationFailed();
+  }
+  const b64auth = headers.authorization.split(" ")[1] || "";
+  const decodedAuthHeader = Buffer.from(b64auth, "base64").toString();
+  if (decodedAuthHeader !== auth) {
+    return authenticationFailed();
+  }
+  return await handler(event);
+});

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

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/api/purgeAll.mjs

@@ -0,0 +1,14 @@
+import { defineEventHandler, setResponseStatus } from "h3";
+import { HttpStatusCode } from "@scayle/storefront-core";
+import { eventHandlerWithCacheAuth } from "./cacheAuth.mjs";
+export default eventHandlerWithCacheAuth(
+  defineEventHandler(async (event) => {
+    try {
+      await event.context.$cache.purgeAll();
+    } catch (e) {
+      setResponseStatus(event, HttpStatusCode.INTERNAL_SERVER_ERROR);
+      return { success: false };
+    }
+    return { success: true };
+  })
+);

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

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/api/purgeTags.mjs

@@ -0,0 +1,19 @@
+import { defineEventHandler, setResponseStatus, readBody } from "h3";
+import { HttpStatusCode } from "@scayle/storefront-core";
+import { eventHandlerWithCacheAuth } from "./cacheAuth.mjs";
+export default eventHandlerWithCacheAuth(
+  defineEventHandler(async (event) => {
+    const tags = await readBody(event);
+    if (!tags?.length) {
+      setResponseStatus(event, HttpStatusCode.BAD_REQUEST);
+      return { success: false };
+    }
+    try {
+      await event.context.$cache.purgeTags(tags);
+    } catch (e) {
+      setResponseStatus(event, HttpStatusCode.INTERNAL_SERVER_ERROR);
+      return { success: false };
+    }
+    return { success: true };
+  })
+);

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

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/api/rpcHandler.mjs

@@ -0,0 +1,15 @@
+import { defineEventHandler, readBody, createError } from "h3";
+import { handler } from "../handler.mjs";
+import { resolveError } from "../error/handler.mjs";
+export default defineEventHandler(async (event) => {
+  const pathComponents = event.path.split("?")[0].split("/");
+  const method = pathComponents[pathComponents.length - 1];
+  const body = await readBody(event);
+  event.context.$rpcContext.log.space("sfc").debug(`RPC Handler: ${method}`);
+  try {
+    return await handler(method, body?.payload, event.context.$rpcContext);
+  } catch (e) {
+    const data = resolveError(e);
+    return createError(data);
+  }
+});

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

@@ -0,0 +1,4 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, {
+    status: string;
+}>;
+export default _default;

package/dist/runtime/api/up.mjs

@@ -0,0 +1,4 @@
+import { defineEventHandler } from "h3";
+export default defineEventHandler((_event) => {
+  return { status: "up" };
+});

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

@@ -0,0 +1,2 @@
+import type { PublicShopConfig } from '../../../module';
+export declare const useAvailableShops: () => import("vue").Ref<PublicShopConfig[]>;

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

@@ -0,0 +1,4 @@
+import { useState } from "nuxt/app";
+export const useAvailableShops = () => {
+  return useState("availableShops", () => []);
+};

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

@@ -0,0 +1,3 @@
+import type { Ref } from 'vue';
+import type { PublicShopConfig } from '../../../module';
+export declare const useCurrentShop: () => Ref<PublicShopConfig>;

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

@@ -0,0 +1,8 @@
+import { useState, useNuxtApp } from "nuxt/app";
+export const useCurrentShop = () => {
+  const nuxt = useNuxtApp();
+  return useState(
+    "currentShop",
+    () => nuxt.$currentShop
+  );
+};

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

@@ -0,0 +1,2 @@
+import { useEventListener } from '@vueuse/core';
+export default useEventListener;

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

@@ -0,0 +1,2 @@
+import { useEventListener } from "@vueuse/core";
+export default useEventListener;

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

@@ -0,0 +1 @@
+export declare function useLog(subSpace?: string): any;

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

@@ -0,0 +1,8 @@
+import { useNuxtApp } from "nuxt/app";
+export function useLog(subSpace) {
+  const log = useNuxtApp().$log;
+  if (subSpace) {
+    return log.space(subSpace);
+  }
+  return log;
+}

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

@@ -0,0 +1,17 @@
+import type { RpcContext, RpcMethodName, RpcMethodParameters, RpcMethodReturnType } from '@scayle/storefront-core';
+import { AsyncDataOptions, NuxtError } from 'nuxt/app';
+type KeysOf<T> = Array<T extends T ? (keyof T extends string ? keyof T : never) : never>;
+export type RpcAsyncDataOptions<TResult> = AsyncDataOptions<TResult, TResult, KeysOf<TResult>, TResult>;
+export interface RpcOptions {
+    autoFetch?: boolean;
+    lazy?: boolean;
+}
+export type Status = 'idle' | 'pending' | 'success' | 'error';
+export declare const useRpc: <N extends RpcMethodName, P extends RpcMethodParameters<N>, TResult extends Awaited<RpcMethodReturnType<N>>, TParams = P extends RpcContext ? undefined : P>(method: N, key: string, params?: any, options?: RpcOptions) => Promise<{
+    data: import("vue").Ref<TResult>;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    error: import("vue").Ref<NuxtError | undefined>;
+    status: import("vue").Ref<Status>;
+}>;
+export {};

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

@@ -0,0 +1,56 @@
+import { useNuxtApp, useState } from "nuxt/app";
+import { useCoreLog } from "../useCoreLog.mjs";
+import { handleError } from "../../utils/error.mjs";
+import { useCurrentShop } from "./useCurrentShop.mjs";
+import { toValue } from "#imports";
+export const useRpc = async (method, key, params, options = { autoFetch: true, lazy: false }) => {
+  const currentShop = useCurrentShop();
+  const log = useCoreLog("rpc");
+  const isAutoFetchEnabled = options?.autoFetch ?? true;
+  log.debug(`useRpc: ${method}`);
+  const data = useState(`${method}-${key}-data`);
+  const fetching = useState(`${method}-${key}-fetching`, () => false);
+  const error = useState(
+    `${method}-${key}-error`,
+    () => void 0
+  );
+  const status = useState(`${method}-${key}-status`, () => "idle");
+  const fetch = async () => {
+    try {
+      status.value = "pending";
+      fetching.value = true;
+      const apiBasePath = currentShop.value?.apiBasePath ?? "/api";
+      const fetch2 = useNuxtApp().ssrContext?.event.$fetch ?? $fetch;
+      data.value = await fetch2(`/rpc/${method}`, {
+        // @ts-ignore
+        method: "POST",
+        body: {
+          payload: toValue(params)
+        },
+        baseURL: apiBasePath,
+        headers: {
+          "x-shop-id": currentShop.value?.shopId + ""
+        }
+      });
+    } catch (e) {
+      error.value = handleError(e);
+    } finally {
+      fetching.value = false;
+      status.value = error.value ? "error" : "success";
+    }
+  };
+  if (isAutoFetchEnabled && status.value === "idle") {
+    if (process.server) {
+      await fetch();
+    } else {
+      options.lazy ? fetch() : await fetch();
+    }
+  }
+  return {
+    data,
+    fetching,
+    fetch,
+    error,
+    status
+  };
+};

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

@@ -0,0 +1,21 @@
+export declare function useSession(): {
+    login: (params: import("@scayle/storefront-core").LoginRequest) => Promise<{
+        oauth: import("@scayle/storefront-core").Oauth | null;
+    }>;
+    register: (params: import("@scayle/storefront-core").RegisterRequest) => Promise<{
+        oauth: import("@scayle/storefront-core").Oauth | null;
+    }>;
+    guestLogin: (params: import("@scayle/storefront-core").GuestRequest) => Promise<{
+        oauth: import("@scayle/storefront-core").Oauth | null;
+    }>;
+    refreshToken: () => Promise<import("@scayle/storefront-core").Oauth | null>;
+    revokeToken: () => Promise<{
+        result: boolean;
+    }>;
+    forgetPassword: (params: import("@scayle/storefront-core").SendResetPasswordEmailRequest) => Promise<{
+        success: boolean;
+    }>;
+    resetPasswordByHash: (params: import("@scayle/storefront-core").UpdatePasswordByHashRequest) => Promise<{
+        oauth: import("@scayle/storefront-core").Oauth | null;
+    }>;
+};

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

@@ -0,0 +1,21 @@
+import { useNuxtApp } from "nuxt/app";
+import { rpcCall } from "../../rpc/rpcCall.mjs";
+import { useCurrentShop } from "./useCurrentShop.mjs";
+import { toValue } from "#imports";
+export function useSession() {
+  const nuxtApp = useNuxtApp();
+  const shop = useCurrentShop();
+  return {
+    login: rpcCall(nuxtApp, "oauthLogin", toValue(shop)),
+    register: rpcCall(nuxtApp, "oauthRegister", toValue(shop)),
+    guestLogin: rpcCall(nuxtApp, "oauthGuestLogin", toValue(shop)),
+    refreshToken: rpcCall(nuxtApp, "refreshAccessToken", toValue(shop)),
+    revokeToken: rpcCall(nuxtApp, "oauthRevokeToken", toValue(shop)),
+    forgetPassword: rpcCall(nuxtApp, "oauthForgetPassword", toValue(shop)),
+    resetPasswordByHash: rpcCall(
+      nuxtApp,
+      "updatePasswordByHash",
+      toValue(shop)
+    )
+  };
+}

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

@@ -0,0 +1,16 @@
+import { ShopUser, UpdatePasswordParams, UseUserParams } from '@scayle/storefront-core';
+export type ExtendedUseUserParams = UseUserParams & {
+    lazy?: boolean;
+};
+export declare function useUser({ autoFetch, lazy, key, }?: ExtendedUseUserParams): Promise<{
+    user: import("vue").ComputedRef<ShopUser | undefined>;
+    isLoggedIn: import("vue").ComputedRef<boolean>;
+    customerType: import("vue").ComputedRef<"guest" | "new" | "existing">;
+    fetching: import("vue").Ref<boolean>;
+    fetch: () => Promise<void>;
+    forceRefresh: () => Promise<void>;
+    updateUser: (payload: Partial<ShopUser>) => Promise<void>;
+    updatePassword: (payload: UpdatePasswordParams) => Promise<void>;
+    error: import("vue").Ref<import("nuxt/app").NuxtError | undefined>;
+    status: import("vue").Ref<import("./useRpc").Status>;
+}>;

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

@@ -0,0 +1,68 @@
+import { useNuxtApp } from "nuxt/app";
+import { computed } from "vue";
+import { rpcCall } from "../../rpc/rpcCall.mjs";
+import { useCoreLog } from "../useCoreLog.mjs";
+import { useRpc } from "./useRpc.mjs";
+import { useCurrentShop } from "./useCurrentShop.mjs";
+import { toValue } from "#imports";
+export async function useUser({
+  autoFetch = true,
+  lazy = false,
+  key = "useUser"
+} = {}) {
+  const nuxtApp = useNuxtApp();
+  const shop = useCurrentShop();
+  const log = useCoreLog("useUser");
+  const { data, fetching, fetch, error, status } = await useRpc(
+    "getUser",
+    key,
+    void 0,
+    {
+      autoFetch,
+      lazy
+    }
+  );
+  const updateUser = async (payload) => {
+    log.debug("Update user");
+    data.value = await rpcCall(
+      nuxtApp,
+      "updateShopUser",
+      toValue(shop)
+    )(payload);
+  };
+  const updatePassword = async (payload) => {
+    log.debug("Update password");
+    const response = await rpcCall(
+      nuxtApp,
+      "updatePassword",
+      toValue(shop)
+    )(payload);
+    if (response) {
+      data.value = response;
+    }
+  };
+  const user = computed(() => data.value?.user);
+  const isLoggedIn = computed(() => !!user.value);
+  const customerType = computed(() => {
+    if (!isLoggedIn.value) {
+      return "guest";
+    }
+    return user.value?.groups?.includes("new") ? "new" : "existing";
+  });
+  const forceRefresh = async () => {
+    log.debug("Refresh user");
+    data.value = await rpcCall(nuxtApp, "refreshUser", toValue(shop))();
+  };
+  return {
+    user,
+    isLoggedIn,
+    customerType,
+    fetching,
+    fetch,
+    forceRefresh,
+    updateUser,
+    updatePassword,
+    error,
+    status
+  };
+}