@carlonicora/nextjs-jsonapi 1.15.0 → 1.17.0

package/scripts/generate-web-module/types/template-data.interface.ts

@@ -170,5 +170,5 @@ export interface GenerateWebModuleOptions {
 export interface GeneratedFile {
   path: string;
   content: string;
-  type: "data" | "component" | "context" | "hook" | "module" | "page";
+  type: "data" | "component" | "context" | "hook" | "module" | "page" | "project-setup";
 }

package/src/client/config.ts

@@ -10,6 +10,7 @@ let _clientConfig: {
   trackablePages?: ModuleWithPermissions[];
   bootstrapper?: () => void;
   additionalHeaders?: Record<string, string>;
+  stripePublishableKey?: string;
 } | null = null;
 
 /**
@@ -22,6 +23,7 @@ export function configureJsonApi(config: {
   trackablePages?: ModuleWithPermissions[];
   bootstrapper?: () => void;
   additionalHeaders?: Record<string, string>;
+  stripePublishableKey?: string;
 }): void {
   _clientConfig = config;
   // Register and call bootstrapper to register all modules
@@ -78,3 +80,10 @@ export function getAppUrl(): string {
 export function getTrackablePages(): ModuleWithPermissions[] {
   return _clientConfig?.trackablePages ?? [];
 }
+
+/**
+ * Get the configured Stripe publishable key.
+ */
+export function getStripePublishableKey(): string | undefined {
+  return _clientConfig?.stripePublishableKey;
+}

package/src/client/hooks/__tests__/useJsonApiGet.test.tsx

@@ -0,0 +1,229 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import React from "react";
+import { useJsonApiGet } from "../useJsonApiGet";
+import { MockJsonApiProvider } from "../../../testing/providers/MockJsonApiProvider";
+import { createMockModule, createMockResponse, createMockApiData } from "../../../testing";
+
+// Mock the JsonApiRequest module
+vi.mock("../../../unified/JsonApiRequest", () => ({
+  JsonApiGet: vi.fn(),
+}));
+
+describe("useJsonApiGet", () => {
+  const mockModule = createMockModule({ name: "articles" });
+  const mockData = createMockApiData({ type: "articles", id: "1", attributes: { title: "Test Article" } });
+
+  const wrapper = ({ children }: { children: React.ReactNode }) => (
+    <MockJsonApiProvider>{children}</MockJsonApiProvider>
+  );
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
+  it("should initialize with loading state", async () => {
+    const { JsonApiGet } = await import("../../../unified/JsonApiRequest");
+    (JsonApiGet as any).mockImplementation(() => new Promise(() => {})); // Never resolves
+
+    const { result } = renderHook(
+      () =>
+        useJsonApiGet({
+          classKey: mockModule,
+          endpoint: "/articles/1",
+        }),
+      { wrapper }
+    );
+
+    expect(result.current.loading).toBe(true);
+    expect(result.current.data).toBeNull();
+    expect(result.current.error).toBeNull();
+  });
+
+  it("should fetch data on mount", async () => {
+    const { JsonApiGet } = await import("../../../unified/JsonApiRequest");
+    const mockResponse = createMockResponse({ data: mockData, ok: true });
+    (JsonApiGet as any).mockResolvedValue(mockResponse);
+
+    const { result } = renderHook(
+      () =>
+        useJsonApiGet({
+          classKey: mockModule,
+          endpoint: "/articles/1",
+        }),
+      { wrapper }
+    );
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.data).toBe(mockData);
+    expect(result.current.error).toBeNull();
+    expect(result.current.response).toBe(mockResponse);
+  });
+
+  it("should not fetch when enabled is false", async () => {
+    const { JsonApiGet } = await import("../../../unified/JsonApiRequest");
+    (JsonApiGet as any).mockResolvedValue(createMockResponse({ data: mockData, ok: true }));
+
+    const { result } = renderHook(
+      () =>
+        useJsonApiGet({
+          classKey: mockModule,
+          endpoint: "/articles/1",
+          options: { enabled: false },
+        }),
+      { wrapper }
+    );
+
+    // Wait a bit to ensure no fetch happens
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(JsonApiGet).not.toHaveBeenCalled();
+    expect(result.current.loading).toBe(false);
+    expect(result.current.data).toBeNull();
+  });
+
+  it("should handle errors", async () => {
+    const { JsonApiGet } = await import("../../../unified/JsonApiRequest");
+    const errorResponse = createMockResponse({
+      ok: false,
+      response: 404,
+      error: "Not Found",
+    });
+    (JsonApiGet as any).mockResolvedValue(errorResponse);
+
+    const { result } = renderHook(
+      () =>
+        useJsonApiGet({
+          classKey: mockModule,
+          endpoint: "/articles/999",
+        }),
+      { wrapper }
+    );
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.data).toBeNull();
+    expect(result.current.error).toBe("Not Found");
+  });
+
+  it("should handle thrown errors", async () => {
+    const { JsonApiGet } = await import("../../../unified/JsonApiRequest");
+    (JsonApiGet as any).mockRejectedValue(new Error("Network error"));
+
+    const { result } = renderHook(
+      () =>
+        useJsonApiGet({
+          classKey: mockModule,
+          endpoint: "/articles/1",
+        }),
+      { wrapper }
+    );
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.error).toBe("Network error");
+  });
+
+  it("should support refetch", async () => {
+    const { JsonApiGet } = await import("../../../unified/JsonApiRequest");
+    let callCount = 0;
+    (JsonApiGet as any).mockImplementation(() => {
+      callCount++;
+      return Promise.resolve(
+        createMockResponse({
+          data: createMockApiData({
+            type: "articles",
+            id: "1",
+            attributes: { title: `Article ${callCount}` },
+          }),
+          ok: true,
+        })
+      );
+    });
+
+    const { result } = renderHook(
+      () =>
+        useJsonApiGet({
+          classKey: mockModule,
+          endpoint: "/articles/1",
+        }),
+      { wrapper }
+    );
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(callCount).toBe(1);
+
+    // Trigger refetch
+    await act(async () => {
+      await result.current.refetch();
+    });
+
+    expect(callCount).toBe(2);
+  });
+
+  it("should indicate pagination availability", async () => {
+    const { JsonApiGet } = await import("../../../unified/JsonApiRequest");
+    const mockResponse = createMockResponse({
+      data: mockData,
+      ok: true,
+      next: "/articles?page=2",
+      prev: "/articles?page=0",
+    });
+    (JsonApiGet as any).mockResolvedValue(mockResponse);
+
+    const { result } = renderHook(
+      () =>
+        useJsonApiGet({
+          classKey: mockModule,
+          endpoint: "/articles",
+        }),
+      { wrapper }
+    );
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.hasNextPage).toBe(true);
+    expect(result.current.hasPreviousPage).toBe(true);
+  });
+
+  it("should handle no pagination", async () => {
+    const { JsonApiGet } = await import("../../../unified/JsonApiRequest");
+    const mockResponse = createMockResponse({
+      data: mockData,
+      ok: true,
+    });
+    (JsonApiGet as any).mockResolvedValue(mockResponse);
+
+    const { result } = renderHook(
+      () =>
+        useJsonApiGet({
+          classKey: mockModule,
+          endpoint: "/articles/1",
+        }),
+      { wrapper }
+    );
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.hasNextPage).toBe(false);
+    expect(result.current.hasPreviousPage).toBe(false);
+  });
+});

package/src/client/hooks/__tests__/useJsonApiMutation.test.tsx

@@ -0,0 +1,348 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, waitFor, act } from "@testing-library/react";
+import React from "react";
+import { useJsonApiMutation } from "../useJsonApiMutation";
+import { MockJsonApiProvider } from "../../../testing/providers/MockJsonApiProvider";
+import { createMockModule, createMockResponse, createMockApiData } from "../../../testing";
+
+// Mock the JsonApiRequest module
+vi.mock("../../../unified/JsonApiRequest", () => ({
+  JsonApiPost: vi.fn(),
+  JsonApiPut: vi.fn(),
+  JsonApiPatch: vi.fn(),
+  JsonApiDelete: vi.fn(),
+}));
+
+describe("useJsonApiMutation", () => {
+  const mockModule = createMockModule({ name: "articles" });
+  const mockData = createMockApiData({
+    type: "articles",
+    id: "1",
+    attributes: { title: "Created Article" },
+  });
+
+  const wrapper = ({ children }: { children: React.ReactNode }) => (
+    <MockJsonApiProvider>{children}</MockJsonApiProvider>
+  );
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.resetModules();
+  });
+
+  describe("POST mutations", () => {
+    it("should initialize with idle state", () => {
+      const { result } = renderHook(
+        () =>
+          useJsonApiMutation({
+            method: "POST",
+            classKey: mockModule,
+          }),
+        { wrapper }
+      );
+
+      expect(result.current.loading).toBe(false);
+      expect(result.current.data).toBeNull();
+      expect(result.current.error).toBeNull();
+      expect(result.current.response).toBeNull();
+    });
+
+    it("should execute POST mutation", async () => {
+      const { JsonApiPost } = await import("../../../unified/JsonApiRequest");
+      const mockResponse = createMockResponse({ data: mockData, ok: true });
+      (JsonApiPost as any).mockResolvedValue(mockResponse);
+
+      const { result } = renderHook(
+        () =>
+          useJsonApiMutation({
+            method: "POST",
+            classKey: mockModule,
+          }),
+        { wrapper }
+      );
+
+      let mutationResult: any;
+      await act(async () => {
+        mutationResult = await result.current.mutate({
+          endpoint: "/articles",
+          body: { title: "New Article" },
+        });
+      });
+
+      expect(result.current.data).toBe(mockData);
+      expect(result.current.error).toBeNull();
+      expect(mutationResult).toBe(mockData);
+      expect(JsonApiPost).toHaveBeenCalled();
+    });
+
+    it("should handle POST errors", async () => {
+      const { JsonApiPost } = await import("../../../unified/JsonApiRequest");
+      const errorResponse = createMockResponse({
+        ok: false,
+        response: 400,
+        error: "Validation failed",
+      });
+      (JsonApiPost as any).mockResolvedValue(errorResponse);
+
+      const { result } = renderHook(
+        () =>
+          useJsonApiMutation({
+            method: "POST",
+            classKey: mockModule,
+          }),
+        { wrapper }
+      );
+
+      let mutationResult: any;
+      await act(async () => {
+        mutationResult = await result.current.mutate({
+          endpoint: "/articles",
+          body: {},
+        });
+      });
+
+      expect(result.current.data).toBeNull();
+      expect(result.current.error).toBe("Validation failed");
+      expect(mutationResult).toBeNull();
+    });
+
+    it("should call onSuccess callback", async () => {
+      const { JsonApiPost } = await import("../../../unified/JsonApiRequest");
+      const mockResponse = createMockResponse({ data: mockData, ok: true });
+      (JsonApiPost as any).mockResolvedValue(mockResponse);
+      const onSuccess = vi.fn();
+
+      const { result } = renderHook(
+        () =>
+          useJsonApiMutation({
+            method: "POST",
+            classKey: mockModule,
+            onSuccess,
+          }),
+        { wrapper }
+      );
+
+      await act(async () => {
+        await result.current.mutate({
+          endpoint: "/articles",
+          body: { title: "New" },
+        });
+      });
+
+      expect(onSuccess).toHaveBeenCalledWith(mockData);
+    });
+
+    it("should call onError callback", async () => {
+      const { JsonApiPost } = await import("../../../unified/JsonApiRequest");
+      const errorResponse = createMockResponse({
+        ok: false,
+        error: "Failed",
+      });
+      (JsonApiPost as any).mockResolvedValue(errorResponse);
+      const onError = vi.fn();
+
+      const { result } = renderHook(
+        () =>
+          useJsonApiMutation({
+            method: "POST",
+            classKey: mockModule,
+            onError,
+          }),
+        { wrapper }
+      );
+
+      await act(async () => {
+        await result.current.mutate({
+          endpoint: "/articles",
+          body: {},
+        });
+      });
+
+      expect(onError).toHaveBeenCalledWith("Failed");
+    });
+  });
+
+  describe("PUT mutations", () => {
+    it("should execute PUT mutation", async () => {
+      const { JsonApiPut } = await import("../../../unified/JsonApiRequest");
+      const mockResponse = createMockResponse({ data: mockData, ok: true });
+      (JsonApiPut as any).mockResolvedValue(mockResponse);
+
+      const { result } = renderHook(
+        () =>
+          useJsonApiMutation({
+            method: "PUT",
+            classKey: mockModule,
+          }),
+        { wrapper }
+      );
+
+      await act(async () => {
+        await result.current.mutate({
+          endpoint: "/articles/1",
+          body: { title: "Updated" },
+        });
+      });
+
+      expect(JsonApiPut).toHaveBeenCalled();
+      expect(result.current.data).toBe(mockData);
+    });
+  });
+
+  describe("PATCH mutations", () => {
+    it("should execute PATCH mutation", async () => {
+      const { JsonApiPatch } = await import("../../../unified/JsonApiRequest");
+      const mockResponse = createMockResponse({ data: mockData, ok: true });
+      (JsonApiPatch as any).mockResolvedValue(mockResponse);
+
+      const { result } = renderHook(
+        () =>
+          useJsonApiMutation({
+            method: "PATCH",
+            classKey: mockModule,
+          }),
+        { wrapper }
+      );
+
+      await act(async () => {
+        await result.current.mutate({
+          endpoint: "/articles/1",
+          body: { title: "Patched" },
+        });
+      });
+
+      expect(JsonApiPatch).toHaveBeenCalled();
+      expect(result.current.data).toBe(mockData);
+    });
+  });
+
+  describe("DELETE mutations", () => {
+    it("should execute DELETE mutation", async () => {
+      const { JsonApiDelete } = await import("../../../unified/JsonApiRequest");
+      const mockResponse = createMockResponse({ data: mockData, ok: true });
+      (JsonApiDelete as any).mockResolvedValue(mockResponse);
+
+      const { result } = renderHook(
+        () =>
+          useJsonApiMutation({
+            method: "DELETE",
+            classKey: mockModule,
+          }),
+        { wrapper }
+      );
+
+      await act(async () => {
+        await result.current.mutate({
+          endpoint: "/articles/1",
+        });
+      });
+
+      expect(JsonApiDelete).toHaveBeenCalled();
+    });
+  });
+
+  describe("reset", () => {
+    it("should reset state", async () => {
+      const { JsonApiPost } = await import("../../../unified/JsonApiRequest");
+      const mockResponse = createMockResponse({ data: mockData, ok: true });
+      (JsonApiPost as any).mockResolvedValue(mockResponse);
+
+      const { result } = renderHook(
+        () =>
+          useJsonApiMutation({
+            method: "POST",
+            classKey: mockModule,
+          }),
+        { wrapper }
+      );
+
+      await act(async () => {
+        await result.current.mutate({
+          endpoint: "/articles",
+          body: {},
+        });
+      });
+
+      expect(result.current.data).not.toBeNull();
+
+      act(() => {
+        result.current.reset();
+      });
+
+      expect(result.current.data).toBeNull();
+      expect(result.current.error).toBeNull();
+      expect(result.current.response).toBeNull();
+      expect(result.current.loading).toBe(false);
+    });
+  });
+
+  describe("loading state", () => {
+    it("should set loading during mutation", async () => {
+      const { JsonApiPost } = await import("../../../unified/JsonApiRequest");
+      let resolvePromise: any;
+      const pendingPromise = new Promise((resolve) => {
+        resolvePromise = resolve;
+      });
+      (JsonApiPost as any).mockReturnValue(pendingPromise);
+
+      const { result } = renderHook(
+        () =>
+          useJsonApiMutation({
+            method: "POST",
+            classKey: mockModule,
+          }),
+        { wrapper }
+      );
+
+      // Start mutation without awaiting
+      act(() => {
+        result.current.mutate({
+          endpoint: "/articles",
+          body: {},
+        });
+      });
+
+      // Should be loading
+      expect(result.current.loading).toBe(true);
+
+      // Resolve the promise
+      await act(async () => {
+        resolvePromise(createMockResponse({ data: mockData, ok: true }));
+      });
+
+      // Loading should be false after completion
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+    });
+  });
+
+  describe("error handling", () => {
+    it("should handle thrown exceptions", async () => {
+      const { JsonApiPost } = await import("../../../unified/JsonApiRequest");
+      (JsonApiPost as any).mockRejectedValue(new Error("Network error"));
+
+      const { result } = renderHook(
+        () =>
+          useJsonApiMutation({
+            method: "POST",
+            classKey: mockModule,
+          }),
+        { wrapper }
+      );
+
+      await act(async () => {
+        await result.current.mutate({
+          endpoint: "/articles",
+          body: {},
+        });
+      });
+
+      expect(result.current.error).toBe("Network error");
+      expect(result.current.data).toBeNull();
+    });
+  });
+});