@ic-reactor/react 3.7.0 → 3.8.0

package/src/hooks/useActorMutation.test.tsx

@@ -1,220 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest"
-import { renderHook } from "@testing-library/react"
-import React from "react"
-import { ClientManager, Reactor } from "@ic-reactor/core"
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
-import { Actor, ActorMethod } from "@icp-sdk/core/agent"
-import { useActorMutation } from "./useActorMutation"
-
-// Mock IDL factory
-const idlFactory = ({ IDL }: any) => {
-  return IDL.Service({
-    create_user: IDL.Func(
-      [IDL.Record({ name: IDL.Text })],
-      [IDL.Record({ id: IDL.Text, name: IDL.Text })],
-      ["update"]
-    ),
-    update_user: IDL.Func(
-      [IDL.Record({ id: IDL.Text, name: IDL.Text })],
-      [IDL.Record({ id: IDL.Text, name: IDL.Text })],
-      ["update"]
-    ),
-    delete_user: IDL.Func([IDL.Text], [IDL.Bool], ["update"]),
-  })
-}
-
-// Define Actor Interface
-interface CreateUserInput {
-  name: string
-}
-
-interface UpdateUserInput {
-  id: string
-  name: string
-}
-
-interface User {
-  id: string
-  name: string
-}
-
-// Actor type with methods
-interface TestActor {
-  get_user: ActorMethod<[string], User>
-  create_user: ActorMethod<[CreateUserInput], User>
-  update_user: ActorMethod<[UpdateUserInput], User>
-  delete_user: ActorMethod<[string], boolean>
-}
-
-// Mock data
-const mockUserCreated: User = { id: "user-1", name: "Alice" }
-const mockUserUpdated: User = { id: "user-1", name: "Bob" }
-
-// Mock Actor.createActor
-vi.mock("@icp-sdk/core/agent", async () => {
-  const actual = await vi.importActual<typeof import("@icp-sdk/core/agent")>(
-    "@icp-sdk/core/agent"
-  )
-  return {
-    ...actual,
-    Actor: class extends actual.Actor {
-      static createActor = vi.fn()
-      static canisterIdOf = vi.fn().mockReturnValue({
-        toString: () => "test-canister-id",
-      })
-      static interfaceOf = vi.fn().mockReturnValue({
-        _fields: [],
-      })
-    },
-  }
-})
-
-describe("useActorMutation", () => {
-  let queryClient: QueryClient
-  let clientManager: ClientManager
-  let mockActor: TestActor
-  let reactor: Reactor<TestActor>
-
-  beforeEach(() => {
-    queryClient = new QueryClient({
-      defaultOptions: {
-        mutations: {
-          retry: false,
-        },
-      },
-    })
-
-    clientManager = new ClientManager({ queryClient })
-
-    // Setup mock actor
-    mockActor = {
-      create_user: vi.fn().mockResolvedValue(mockUserCreated),
-      update_user: vi.fn().mockResolvedValue(mockUserUpdated),
-      delete_user: vi.fn().mockResolvedValue(true),
-    } as unknown as TestActor
-    ;(Actor.createActor as any).mockReturnValue(mockActor)
-
-    reactor = new Reactor<TestActor>({
-      clientManager,
-      canisterId: "rrkah-fqaaa-aaaaa-aaaaq-cai",
-      idlFactory,
-      name: "test",
-    })
-  })
-
-  const wrapper = ({ children }: { children: React.ReactNode }) => (
-    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-  )
-
-  describe("basic functionality", () => {
-    it("should create a mutation hook", () => {
-      const { result } = renderHook(
-        () =>
-          useActorMutation({
-            reactor,
-            functionName: "create_user",
-          }),
-        { wrapper }
-      )
-
-      expect(result.current).toBeDefined()
-    })
-
-    it("should return correct hook structure", () => {
-      const { result } = renderHook(
-        () =>
-          useActorMutation({
-            reactor,
-            functionName: "create_user",
-          }),
-        { wrapper }
-      )
-
-      expect(result.current.mutate).toBeInstanceOf(Function)
-      expect(result.current.mutateAsync).toBeInstanceOf(Function)
-      expect(typeof result.current.isPending).toBe("boolean")
-      expect(typeof result.current.isSuccess).toBe("boolean")
-      expect(typeof result.current.isError).toBe("boolean")
-    })
-
-    it("should have correct initial state", () => {
-      const { result } = renderHook(
-        () =>
-          useActorMutation({
-            reactor,
-            functionName: "create_user",
-          }),
-        { wrapper }
-      )
-
-      expect(result.current.isPending).toBe(false)
-      expect(result.current.isSuccess).toBe(false)
-      expect(result.current.isError).toBe(false)
-      expect(result.current.data).toBeUndefined()
-    })
-  })
-
-  describe("hook options", () => {
-    it("should accept mutation options like onSuccess and onError", () => {
-      const onSuccess = vi.fn()
-      const onError = vi.fn()
-
-      const { result } = renderHook(
-        () =>
-          useActorMutation({
-            reactor,
-            functionName: "create_user",
-            onSuccess,
-            onError,
-          }),
-        { wrapper }
-      )
-
-      expect(result.current.mutate).toBeInstanceOf(Function)
-    })
-
-    it("should expose mutate and mutateAsync methods", () => {
-      const { result } = renderHook(
-        () =>
-          useActorMutation({
-            reactor,
-            functionName: "create_user",
-          }),
-        { wrapper }
-      )
-
-      expect(result.current.mutate).toBeInstanceOf(Function)
-      expect(result.current.mutateAsync).toBeInstanceOf(Function)
-    })
-  })
-
-  describe("invalidateQueries functionality", () => {
-    it("should accept invalidateQueries option", () => {
-      const { result } = renderHook(
-        () =>
-          useActorMutation({
-            reactor,
-            functionName: "update_user",
-            invalidateQueries: [["test-canister", "get_user"]],
-          }),
-        { wrapper }
-      )
-
-      expect(result.current.mutate).toBeInstanceOf(Function)
-    })
-
-    it("should support invalidateQueries with args", () => {
-      const { result } = renderHook(
-        () =>
-          useActorMutation({
-            reactor,
-            functionName: "update_user",
-            invalidateQueries: [["test-canister", "get_user", "user-1"]],
-          }),
-        { wrapper }
-      )
-
-      expect(result.current.mutate).toBeInstanceOf(Function)
-    })
-  })
-})

package/src/hooks/useActorQuery.test.tsx

@@ -1,287 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest"
-import { renderHook, waitFor } from "@testing-library/react"
-import React from "react"
-import { QueryClient, QueryClientProvider } from "@tanstack/react-query"
-import { useActorQuery } from "./useActorQuery"
-import { ActorMethod } from "@icp-sdk/core/agent"
-import { Reactor } from "@ic-reactor/core"
-
-// Define a test actor type
-type TestActor = {
-  greet: ActorMethod<[], string>
-  greetWithName: ActorMethod<[string], string>
-  getCount: ActorMethod<[], bigint>
-}
-
-// Mock Reactor
-const createMockReactor = (queryClient: QueryClient): Reactor<TestActor> =>
-  ({
-    queryClient,
-    getQueryOptions: vi.fn().mockImplementation(({ functionName, args }) => ({
-      queryKey: ["test-canister", functionName, ...(args || [])],
-      queryFn: vi.fn().mockImplementation(async () => {
-        if (functionName === "greet") return "Hello, World!"
-        if (functionName === "greetWithName")
-          return `Hello, ${args?.[0] || "Guest"}!`
-        if (functionName === "getCount") return BigInt(42)
-        return null
-      }),
-    })),
-  }) as unknown as Reactor<TestActor>
-
-describe("useActorQuery", () => {
-  let queryClient: QueryClient
-  let mockReactor: Reactor<TestActor>
-
-  beforeEach(() => {
-    queryClient = new QueryClient({
-      defaultOptions: {
-        queries: {
-          retry: false,
-        },
-      },
-    })
-    mockReactor = createMockReactor(queryClient)
-  })
-
-  const wrapper = ({ children }: { children: React.ReactNode }) => (
-    <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
-  )
-
-  describe("basic functionality", () => {
-    it("should fetch data without select", async () => {
-      const { result } = renderHook(
-        () =>
-          useActorQuery<TestActor, "greet">({
-            reactor: mockReactor,
-            functionName: "greet",
-          }),
-        { wrapper }
-      )
-
-      await waitFor(() => {
-        expect(result.current.isSuccess).toBe(true)
-      })
-
-      expect(result.current.data).toBe("Hello, World!")
-    })
-
-    it("should pass args to the query", async () => {
-      const { result } = renderHook(
-        () =>
-          useActorQuery<TestActor, "greetWithName">({
-            reactor: mockReactor,
-            functionName: "greetWithName",
-            args: ["Alice"],
-          }),
-        { wrapper }
-      )
-
-      await waitFor(() => {
-        expect(result.current.isSuccess).toBe(true)
-      })
-
-      expect(result.current.data).toBe("Hello, Alice!")
-      expect(mockReactor.getQueryOptions).toHaveBeenCalledWith({
-        callConfig: undefined,
-        functionName: "greetWithName",
-        args: ["Alice"],
-      })
-    })
-
-    it("should handle bigint return types", async () => {
-      const { result } = renderHook(
-        () =>
-          useActorQuery<TestActor, "getCount">({
-            reactor: mockReactor,
-            functionName: "getCount",
-          }),
-        { wrapper }
-      )
-
-      await waitFor(() => {
-        expect(result.current.isSuccess).toBe(true)
-      })
-
-      expect(result.current.data).toBe(BigInt(42))
-    })
-  })
-
-  describe("select function", () => {
-    it("should transform data with select function", async () => {
-      const { result } = renderHook(
-        () =>
-          useActorQuery<TestActor, "greet", "candid", number>({
-            reactor: mockReactor,
-            functionName: "greet",
-            select: (data: string) => data.length,
-          }),
-        { wrapper }
-      )
-
-      await waitFor(() => {
-        expect(result.current.isSuccess).toBe(true)
-      })
-
-      // "Hello, World!" has 13 characters
-      expect(result.current.data).toBe(13)
-    })
-
-    it("should transform data to different type with select", async () => {
-      const { result } = renderHook(
-        () =>
-          useActorQuery<TestActor, "greet", "candid", { message: string }>({
-            reactor: mockReactor,
-            functionName: "greet",
-            select: (data: string) => ({ message: data }),
-          }),
-        { wrapper }
-      )
-
-      await waitFor(() => {
-        expect(result.current.isSuccess).toBe(true)
-      })
-
-      expect(result.current.data).toEqual({ message: "Hello, World!" })
-    })
-
-    it("should transform bigint to number with select", async () => {
-      const { result } = renderHook(
-        () =>
-          useActorQuery<TestActor, "getCount", "candid", number>({
-            reactor: mockReactor,
-            functionName: "getCount",
-            select: (data: bigint) => Number(data),
-          }),
-        { wrapper }
-      )
-
-      await waitFor(() => {
-        expect(result.current.isSuccess).toBe(true)
-      })
-
-      expect(result.current.data).toBe(42)
-      expect(typeof result.current.data).toBe("number")
-    })
-
-    it("should work with array transformation in select", async () => {
-      const { result } = renderHook(
-        () =>
-          useActorQuery<TestActor, "greet", "candid", string[]>({
-            reactor: mockReactor,
-            functionName: "greet",
-            select: (data: string) => data.split(", "),
-          }),
-        { wrapper }
-      )
-
-      await waitFor(() => {
-        expect(result.current.isSuccess).toBe(true)
-      })
-
-      expect(result.current.data).toEqual(["Hello", "World!"])
-    })
-  })
-
-  describe("query options", () => {
-    it("should respect enabled: false option", async () => {
-      const { result } = renderHook(
-        () =>
-          useActorQuery<TestActor, "greet">({
-            reactor: mockReactor,
-            functionName: "greet",
-            enabled: false,
-          }),
-        { wrapper }
-      )
-
-      // Should stay in pending state
-      expect(result.current.isPending).toBe(true)
-      expect(result.current.fetchStatus).toBe("idle")
-      expect(result.current.data).toBeUndefined()
-    })
-
-    it("should use custom staleTime", async () => {
-      const { result } = renderHook(
-        () =>
-          useActorQuery<TestActor, "greet">({
-            reactor: mockReactor,
-            functionName: "greet",
-            staleTime: 1000 * 60 * 10, // 10 minutes
-          }),
-        { wrapper }
-      )
-
-      await waitFor(() => {
-        expect(result.current.isSuccess).toBe(true)
-      })
-
-      expect(result.current.isStale).toBe(false)
-    })
-  })
-
-  describe("type inference", () => {
-    it("should infer string type for greet method without select", async () => {
-      const { result } = renderHook(
-        () =>
-          useActorQuery<TestActor, "greet">({
-            reactor: mockReactor,
-            functionName: "greet",
-          }),
-        { wrapper }
-      )
-
-      await waitFor(() => {
-        expect(result.current.isSuccess).toBe(true)
-      })
-
-      // TypeScript should infer data as string
-      const data: string | undefined = result.current.data
-      expect(typeof data).toBe("string")
-    })
-
-    it("should infer number type when select returns number", async () => {
-      const { result } = renderHook(
-        () =>
-          useActorQuery({
-            reactor: mockReactor,
-            functionName: "greet",
-            select: (data: any) => data.length,
-          }),
-        { wrapper }
-      )
-
-      await waitFor(() => {
-        expect(result.current.isSuccess).toBe(true)
-      })
-
-      // TypeScript should infer data as number
-      const data: number | undefined = result.current.data
-      expect(typeof data).toBe("number")
-    })
-  })
-
-  describe("refetching", () => {
-    it("should support manual refetch", async () => {
-      const { result } = renderHook(
-        () =>
-          useActorQuery<TestActor, "greet">({
-            reactor: mockReactor,
-            functionName: "greet",
-          }),
-        { wrapper }
-      )
-
-      await waitFor(() => {
-        expect(result.current.isSuccess).toBe(true)
-      })
-
-      // Refetch should be available
-      expect(typeof result.current.refetch).toBe("function")
-
-      await result.current.refetch()
-
-      expect(result.current.isSuccess).toBe(true)
-    })
-  })
-})