feat(storefront-data): add auth module

Author: KaiUweCZE

libs/storefront-data/src/auth/hooks.ts

@@ -0,0 +1,190 @@
+import {
+  useMutation,
+  useQuery,
+  useQueryClient,
+  useSuspenseQuery,
+} from "@tanstack/react-query"
+import { createCacheConfig, type CacheConfig } from "../shared/cache-config"
+import type { QueryNamespace } from "../shared/query-keys"
+import { createAuthQueryKeys } from "./query-keys"
+import type {
+  AuthQueryInput,
+  AuthQueryKeys,
+  AuthService,
+  UseAuthResult,
+  UseSuspenseAuthResult,
+} from "./types"
+
+export type CreateAuthHooksConfig<
+  TCustomer,
+  TLoginInput,
+  TRegisterInput,
+  TUpdateInput,
+> = {
+  service: AuthService<TCustomer, TLoginInput, TRegisterInput, TUpdateInput>
+  queryKeys?: AuthQueryKeys
+  queryKeyNamespace?: QueryNamespace
+  cacheConfig?: CacheConfig
+}
+
+export type AuthMutationOptions<TData, TVariables> = {
+  onSuccess?: (data: TData, variables: TVariables) => void
+  onError?: (error: unknown) => void
+}
+
+export function createAuthHooks<
+  TCustomer,
+  TLoginInput,
+  TRegisterInput,
+  TUpdateInput,
+>({
+  service,
+  queryKeys,
+  queryKeyNamespace = "storefront-data",
+  cacheConfig,
+}: CreateAuthHooksConfig<TCustomer, TLoginInput, TRegisterInput, TUpdateInput>) {
+  const resolvedCacheConfig = cacheConfig ?? createCacheConfig()
+  const resolvedQueryKeys =
+    queryKeys ?? createAuthQueryKeys(queryKeyNamespace)
+
+  function useAuth(options?: AuthQueryInput): UseAuthResult<TCustomer> {
+    const { data, isLoading, isFetching, isSuccess, error } = useQuery({
+      queryKey: resolvedQueryKeys.customer(),
+      queryFn: ({ signal }) => service.getCustomer(signal),
+      enabled: options?.enabled ?? true,
+      retry: false,
+      ...resolvedCacheConfig.userData,
+    })
+
+    const customer = data ?? null
+
+    return {
+      customer,
+      isAuthenticated: customer !== null,
+      isLoading,
+      isFetching,
+      isSuccess,
+      error:
+        error instanceof Error ? error.message : error ? String(error) : null,
+    }
+  }
+
+  function useSuspenseAuth(): UseSuspenseAuthResult<TCustomer> {
+    const { data, isFetching } = useSuspenseQuery<TCustomer | null, Error>({
+      queryKey: resolvedQueryKeys.customer(),
+      queryFn: ({ signal }) => service.getCustomer(signal),
+      ...resolvedCacheConfig.userData,
+    })
+    const customer = data ?? null
+
+    return {
+      customer,
+      isAuthenticated: customer !== null,
+      isFetching,
+    }
+  }
+
+  function useLogin(options?: AuthMutationOptions<unknown, TLoginInput>) {
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: (input: TLoginInput) => service.login(input),
+      onSuccess: (data, variables) => {
+        queryClient.invalidateQueries({
+          queryKey: resolvedQueryKeys.customer(),
+        })
+        options?.onSuccess?.(data, variables)
+      },
+      onError: (error) => {
+        options?.onError?.(error)
+      },
+    })
+  }
+
+  function useRegister(options?: AuthMutationOptions<unknown, TRegisterInput>) {
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: (input: TRegisterInput) => service.register(input),
+      onSuccess: (data, variables) => {
+        queryClient.invalidateQueries({
+          queryKey: resolvedQueryKeys.customer(),
+        })
+        options?.onSuccess?.(data, variables)
+      },
+      onError: (error) => {
+        options?.onError?.(error)
+      },
+    })
+  }
+
+  function useLogout(options?: AuthMutationOptions<void, void>) {
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: () => service.logout(),
+      onSuccess: () => {
+        queryClient.setQueryData(resolvedQueryKeys.customer(), null)
+        queryClient.invalidateQueries({
+          queryKey: resolvedQueryKeys.all(),
+        })
+        queryClient.removeQueries({
+          queryKey: resolvedQueryKeys.all(),
+        })
+        options?.onSuccess?.(undefined, undefined)
+      },
+      onError: (error) => {
+        options?.onError?.(error)
+      },
+    })
+  }
+
+  function useUpdateCustomer(
+    options?: AuthMutationOptions<TCustomer, TUpdateInput>
+  ) {
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: (input: TUpdateInput) => {
+        if (!service.updateCustomer) {
+          throw new Error("updateCustomer service is not configured")
+        }
+        return service.updateCustomer(input)
+      },
+      onSuccess: (data, variables) => {
+        queryClient.setQueryData(resolvedQueryKeys.customer(), data)
+        options?.onSuccess?.(data, variables)
+      },
+      onError: (error) => {
+        options?.onError?.(error)
+      },
+    })
+  }
+
+  function useRefreshAuth(options?: AuthMutationOptions<unknown, void>) {
+    const queryClient = useQueryClient()
+    return useMutation({
+      mutationFn: () => {
+        if (!service.refresh) {
+          throw new Error("refresh service is not configured")
+        }
+        return service.refresh()
+      },
+      onSuccess: (data) => {
+        queryClient.invalidateQueries({
+          queryKey: resolvedQueryKeys.customer(),
+        })
+        options?.onSuccess?.(data, undefined)
+      },
+      onError: (error) => {
+        options?.onError?.(error)
+      },
+    })
+  }
+
+  return {
+    useAuth,
+    useSuspenseAuth,
+    useLogin,
+    useRegister,
+    useLogout,
+    useUpdateCustomer,
+    useRefreshAuth,
+  }
+}

libs/storefront-data/src/auth/index.ts

@@ -0,0 +1,10 @@
+export { createAuthHooks } from "./hooks"
+export { createAuthQueryKeys } from "./query-keys"
+export type { AuthMutationOptions, CreateAuthHooksConfig } from "./hooks"
+export type {
+  AuthQueryInput,
+  AuthQueryKeys,
+  AuthService,
+  UseAuthResult,
+  UseSuspenseAuthResult,
+} from "./types"

libs/storefront-data/src/auth/query-keys.ts

@@ -0,0 +1,13 @@
+import { createQueryKey } from "../shared/query-keys"
+import type { QueryNamespace } from "../shared/query-keys"
+import type { AuthQueryKeys } from "./types"
+
+export function createAuthQueryKeys(
+  namespace: QueryNamespace
+): AuthQueryKeys {
+  return {
+    all: () => createQueryKey(namespace, "auth"),
+    customer: () => createQueryKey(namespace, "auth", "customer"),
+    session: () => createQueryKey(namespace, "auth", "session"),
+  }
+}

libs/storefront-data/src/auth/types.ts

@@ -0,0 +1,40 @@
+import type { QueryKey } from "../shared/query-keys"
+
+export type AuthQueryKeys = {
+  all: () => QueryKey
+  customer: () => QueryKey
+  session: () => QueryKey
+}
+
+export type AuthService<
+  TCustomer,
+  TLoginInput,
+  TRegisterInput,
+  TUpdateInput,
+> = {
+  getCustomer: (signal?: AbortSignal) => Promise<TCustomer | null>
+  login: (input: TLoginInput) => Promise<unknown>
+  logout: () => Promise<void>
+  register: (input: TRegisterInput) => Promise<unknown>
+  updateCustomer?: (input: TUpdateInput) => Promise<TCustomer>
+  refresh?: () => Promise<unknown>
+}
+
+export type AuthQueryInput = {
+  enabled?: boolean
+}
+
+export type UseAuthResult<TCustomer> = {
+  customer: TCustomer | null
+  isAuthenticated: boolean
+  isLoading: boolean
+  isFetching: boolean
+  isSuccess: boolean
+  error: string | null
+}
+
+export type UseSuspenseAuthResult<TCustomer> = {
+  customer: TCustomer | null
+  isAuthenticated: boolean
+  isFetching: boolean
+}