@carlonicora/nextjs-jsonapi 1.16.0 → 1.17.0

package/src/components/tables/__tests__/ContentListTable.test.tsx

@@ -0,0 +1,411 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, fireEvent } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { ContentListTable } from "../ContentListTable";
+import { DataListRetriever } from "../../../hooks";
+import React from "react";
+
+// Mock useTableGenerator hook
+vi.mock("../../../hooks", async () => {
+  const actual = await vi.importActual("../../../hooks");
+  return {
+    ...actual,
+    useTableGenerator: vi.fn((_, params) => ({
+      data: params.data.map((item: any, index: number) => ({
+        ...item,
+        _rowIndex: index,
+      })),
+      columns: [
+        {
+          id: "id",
+          header: "ID",
+          accessorKey: "id",
+          cell: ({ row }: any) => row.original.id,
+        },
+        {
+          id: "title",
+          header: "Title",
+          accessorKey: "title",
+          cell: ({ row }: any) => row.original.title,
+        },
+      ],
+    })),
+  };
+});
+
+// Mock ContentTableSearch
+vi.mock("../ContentTableSearch", () => ({
+  ContentTableSearch: () => <div data-testid="content-table-search">Search</div>,
+}));
+
+// Create a mock DataListRetriever
+function createMockDataRetriever(overrides: Partial<DataListRetriever<any>> = {}): DataListRetriever<any> {
+  return {
+    ready: true,
+    setReady: vi.fn(),
+    isLoaded: true,
+    data: [],
+    search: vi.fn(),
+    refresh: vi.fn(),
+    addAdditionalParameter: vi.fn(),
+    removeAdditionalParameter: vi.fn(),
+    setRefreshedElement: vi.fn(),
+    removeElement: vi.fn(),
+    isSearch: false,
+    ...overrides,
+  };
+}
+
+const mockModule = {
+  name: "articles",
+  model: class MockArticle {},
+};
+
+describe("ContentListTable", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("rendering", () => {
+    it("should render table", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [
+          { id: "1", title: "Article 1" },
+          { id: "2", title: "Article 2" },
+        ],
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+        />
+      );
+
+      expect(screen.getByRole("table")).toBeInTheDocument();
+    });
+
+    it("should render title when provided", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+          title="Articles"
+        />
+      );
+
+      expect(screen.getByText("Articles")).toBeInTheDocument();
+    });
+
+    it("should render table headers", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+        />
+      );
+
+      expect(screen.getByText("ID")).toBeInTheDocument();
+      expect(screen.getByText("Title")).toBeInTheDocument();
+    });
+
+    it("should render table rows with data", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [
+          { id: "1", title: "First Article" },
+          { id: "2", title: "Second Article" },
+        ],
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+        />
+      );
+
+      expect(screen.getByText("1")).toBeInTheDocument();
+      expect(screen.getByText("First Article")).toBeInTheDocument();
+      expect(screen.getByText("2")).toBeInTheDocument();
+      expect(screen.getByText("Second Article")).toBeInTheDocument();
+    });
+
+    it("should render 'No results' when data is empty", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [],
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+        />
+      );
+
+      expect(screen.getByText("No results.")).toBeInTheDocument();
+    });
+  });
+
+  describe("search", () => {
+    it("should render search component when allowSearch is true and title is set", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+          title="Articles"
+          allowSearch={true}
+        />
+      );
+
+      expect(screen.getByTestId("content-table-search")).toBeInTheDocument();
+    });
+  });
+
+  describe("pagination", () => {
+    it("should render pagination buttons when next or previous is available", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+        next: vi.fn(),
+        previous: vi.fn(),
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+        />
+      );
+
+      // Should have navigation buttons
+      const buttons = screen.getAllByRole("button");
+      expect(buttons.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it("should disable previous button when no previous page", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+        next: vi.fn(),
+        previous: undefined,
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+        />
+      );
+
+      const buttons = screen.getAllByRole("button");
+      const previousButton = buttons[0];
+      expect(previousButton).toBeDisabled();
+    });
+
+    it("should disable next button when no next page", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+        next: undefined,
+        previous: vi.fn(),
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+        />
+      );
+
+      const buttons = screen.getAllByRole("button");
+      const nextButton = buttons[buttons.length - 1];
+      expect(nextButton).toBeDisabled();
+    });
+
+    it("should call next when next button is clicked", async () => {
+      const user = userEvent.setup();
+      const nextFn = vi.fn();
+
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+        next: nextFn,
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+        />
+      );
+
+      const buttons = screen.getAllByRole("button");
+      const nextButton = buttons[buttons.length - 1];
+      await user.click(nextButton);
+
+      expect(nextFn).toHaveBeenCalledWith(true);
+    });
+
+    it("should call previous when previous button is clicked", async () => {
+      const user = userEvent.setup();
+      const previousFn = vi.fn();
+
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+        previous: previousFn,
+        next: vi.fn(), // Need both to show footer
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+        />
+      );
+
+      const buttons = screen.getAllByRole("button");
+      const previousButton = buttons[0];
+      await user.click(previousButton);
+
+      expect(previousFn).toHaveBeenCalledWith(true);
+    });
+
+    it("should display page info when available", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+        next: vi.fn(),
+        pageInfo: {
+          startItem: 1,
+          endItem: 25,
+          pageSize: 25,
+        },
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+        />
+      );
+
+      expect(screen.getByText("1-25")).toBeInTheDocument();
+    });
+  });
+
+  describe("functions and filters", () => {
+    it("should render functions when provided", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+          title="Articles"
+          functions={<button data-testid="custom-function">Custom</button>}
+        />
+      );
+
+      expect(screen.getByTestId("custom-function")).toBeInTheDocument();
+    });
+
+    it("should render filters when provided", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+          title="Articles"
+          filters={<div data-testid="custom-filter">Filter</div>}
+        />
+      );
+
+      expect(screen.getByTestId("custom-filter")).toBeInTheDocument();
+    });
+  });
+
+  describe("footer visibility", () => {
+    it("should show footer when functions are provided", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+          functions={<button>Action</button>}
+        />
+      );
+
+      // Footer should be present with buttons
+      const buttons = screen.getAllByRole("button");
+      expect(buttons.length).toBeGreaterThan(0);
+    });
+
+    it("should show footer when next page is available", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+        next: vi.fn(),
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+        />
+      );
+
+      // Should have navigation buttons in footer
+      const buttons = screen.getAllByRole("button");
+      expect(buttons.length).toBeGreaterThanOrEqual(2);
+    });
+
+    it("should show footer when previous page is available", () => {
+      const dataRetriever = createMockDataRetriever({
+        data: [{ id: "1", title: "Article 1" }],
+        previous: vi.fn(),
+      });
+
+      render(
+        <ContentListTable
+          data={dataRetriever}
+          tableGeneratorType={mockModule as any}
+          fields={["id", "title"]}
+        />
+      );
+
+      // Should have navigation buttons in footer
+      const buttons = screen.getAllByRole("button");
+      expect(buttons.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+});

package/src/core/endpoint/__tests__/EndpointCreator.test.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect } from "vitest";
+import { EndpointCreator } from "../EndpointCreator";
+import { createMockModule } from "../../../testing";
+
+describe("EndpointCreator", () => {
+  describe("basic URL generation", () => {
+    it("should generate URL from string endpoint", () => {
+      const creator = new EndpointCreator({ endpoint: "articles" });
+      expect(creator.generate()).toBe("articles");
+    });
+
+    it("should generate URL from module endpoint", () => {
+      const mockModule = createMockModule({ name: "articles" });
+      const creator = new EndpointCreator({ endpoint: mockModule });
+      expect(creator.generate()).toBe("articles");
+    });
+
+    it("should include id in URL", () => {
+      const creator = new EndpointCreator({ endpoint: "articles", id: "123" });
+      expect(creator.generate()).toBe("articles/123");
+    });
+
+    it("should include child endpoint", () => {
+      const creator = new EndpointCreator({
+        endpoint: "articles",
+        id: "123",
+        childEndpoint: "comments",
+      });
+      expect(creator.generate()).toBe("articles/123/comments");
+    });
+
+    it("should include child id", () => {
+      const creator = new EndpointCreator({
+        endpoint: "articles",
+        id: "123",
+        childEndpoint: "comments",
+        childId: "456",
+      });
+      expect(creator.generate()).toBe("articles/123/comments/456");
+    });
+  });
+
+  describe("fluent API", () => {
+    it("should support chaining endpoint()", () => {
+      const creator = new EndpointCreator({ endpoint: "initial" });
+      const result = creator.endpoint("articles");
+      expect(result).toBe(creator);
+      expect(creator.generate()).toBe("articles");
+    });
+
+    it("should support chaining id()", () => {
+      const creator = new EndpointCreator({ endpoint: "articles" });
+      const result = creator.id("123");
+      expect(result).toBe(creator);
+      expect(creator.generate()).toBe("articles/123");
+    });
+
+    it("should support chaining childEndpoint()", () => {
+      const creator = new EndpointCreator({ endpoint: "articles", id: "123" });
+      const result = creator.childEndpoint("comments");
+      expect(result).toBe(creator);
+      expect(creator.generate()).toBe("articles/123/comments");
+    });
+
+    it("should support chaining childId()", () => {
+      const creator = new EndpointCreator({
+        endpoint: "articles",
+        id: "123",
+        childEndpoint: "comments",
+      });
+      const result = creator.childId("456");
+      expect(result).toBe(creator);
+      expect(creator.generate()).toBe("articles/123/comments/456");
+    });
+
+    it("should support full fluent chain", () => {
+      const creator = new EndpointCreator({ endpoint: "articles" })
+        .id("123")
+        .childEndpoint("comments")
+        .childId("456");
+      expect(creator.generate()).toBe("articles/123/comments/456");
+    });
+  });
+
+  describe("query parameters", () => {
+    it("should add additional params", () => {
+      const creator = new EndpointCreator({
+        endpoint: "articles",
+        additionalParams: [{ key: "page", value: "1" }],
+      });
+      expect(creator.generate()).toBe("articles?page=1");
+    });
+
+    it("should support addAdditionalParam()", () => {
+      const creator = new EndpointCreator({ endpoint: "articles" });
+      creator.addAdditionalParam("page", "1");
+      creator.addAdditionalParam("limit", "10");
+      expect(creator.generate()).toBe("articles?page=1&limit=10");
+    });
+
+    it("should support array values in params", () => {
+      const creator = new EndpointCreator({ endpoint: "articles" });
+      creator.addAdditionalParam("filter", ["tag1", "tag2"]);
+      expect(creator.generate()).toBe("articles?filter=tag1,tag2");
+    });
+
+    it("should combine URL and params", () => {
+      const creator = new EndpointCreator({
+        endpoint: "articles",
+        id: "123",
+      });
+      creator.addAdditionalParam("include", "author");
+      expect(creator.generate()).toBe("articles/123?include=author");
+    });
+  });
+
+  describe("limitToType", () => {
+    it("should add include param with single type", () => {
+      const creator = new EndpointCreator({ endpoint: "articles" });
+      creator.limitToType(["author"]);
+      expect(creator.generate()).toBe("articles?include=author");
+    });
+
+    it("should add include param with multiple types", () => {
+      const creator = new EndpointCreator({ endpoint: "articles" });
+      creator.limitToType(["author", "comments", "tags"]);
+      expect(creator.generate()).toBe("articles?include=author,comments,tags");
+    });
+  });
+
+  describe("limitToFields", () => {
+    it("should add fields param with single selector", () => {
+      const creator = new EndpointCreator({ endpoint: "articles" });
+      creator.limitToFields([{ type: "articles", fields: ["title", "body"] }]);
+      expect(creator.generate()).toBe("articles?fields[articles]=title,body");
+    });
+
+    it("should add fields param with multiple selectors", () => {
+      const creator = new EndpointCreator({ endpoint: "articles" });
+      creator.limitToFields([
+        { type: "articles", fields: ["title", "body"] },
+        { type: "authors", fields: ["name", "email"] },
+      ]);
+      expect(creator.generate()).toBe(
+        "articles?fields[articles]=title,body&fields[authors]=name,email"
+      );
+    });
+
+    it("should handle empty selectors array", () => {
+      const creator = new EndpointCreator({ endpoint: "articles" });
+      creator.limitToFields([]);
+      expect(creator.generate()).toBe("articles");
+    });
+  });
+
+  describe("module endpoint support", () => {
+    it("should work with module as child endpoint", () => {
+      const parentModule = createMockModule({ name: "users" });
+      const childModule = createMockModule({ name: "posts" });
+      const creator = new EndpointCreator({
+        endpoint: parentModule,
+        id: "1",
+        childEndpoint: childModule,
+      });
+      expect(creator.generate()).toBe("users/1/posts");
+    });
+  });
+});

package/src/core/factories/__tests__/JsonApiDataFactory.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { JsonApiDataFactory } from "../JsonApiDataFactory";
+import { DataClassRegistry } from "../../registry/DataClassRegistry";
+import { ApiDataInterface } from "../../interfaces/ApiDataInterface";
+
+// Mock class that tracks createJsonApi calls
+class MockDataClass implements Partial<ApiDataInterface> {
+  type = "articles";
+  id = "1";
+
+  createJsonApi = vi.fn((data: any) => ({
+    type: "articles",
+    attributes: data,
+  }));
+
+  get included() {
+    return [];
+  }
+  get createdAt() {
+    return new Date();
+  }
+  get updatedAt() {
+    return new Date();
+  }
+  get self() {
+    return "/articles/1";
+  }
+  get jsonApi() {
+    return { type: this.type, id: this.id };
+  }
+  generateApiUrl() {
+    return `/articles/${this.id}`;
+  }
+  dehydrate() {
+    return { jsonApi: this.jsonApi, included: [], allData: [] };
+  }
+  rehydrate(data: any) {
+    return this;
+  }
+}
+
+describe("JsonApiDataFactory", () => {
+  const mockModule = { name: "articles", model: MockDataClass };
+
+  beforeEach(() => {
+    DataClassRegistry.clear();
+    vi.clearAllMocks();
+  });
+
+  describe("create", () => {
+    it("should create JSON:API formatted data", () => {
+      DataClassRegistry.registerObjectClass(mockModule as any, MockDataClass as any);
+
+      const inputData = { title: "Test Article", body: "Content" };
+      const result = JsonApiDataFactory.create(mockModule as any, inputData);
+
+      expect(result).toEqual({
+        type: "articles",
+        attributes: inputData,
+      });
+    });
+
+    it("should use the registered class to create data", () => {
+      DataClassRegistry.registerObjectClass(mockModule as any, MockDataClass as any);
+
+      const inputData = { title: "Test" };
+      JsonApiDataFactory.create(mockModule as any, inputData);
+
+      // The create method should have been called
+      // Note: We can't directly verify createJsonApi was called since
+      // it's called on a new instance, but we can verify the output format
+    });
+
+    it("should throw for unregistered module", () => {
+      const unregisteredModule = { name: "unknown", model: MockDataClass };
+
+      expect(() =>
+        JsonApiDataFactory.create(unregisteredModule as any, { data: "test" })
+      ).toThrow("Class not registered for key: unknown");
+    });
+
+    it("should handle empty data", () => {
+      DataClassRegistry.registerObjectClass(mockModule as any, MockDataClass as any);
+
+      const result = JsonApiDataFactory.create(mockModule as any, {});
+
+      expect(result).toEqual({
+        type: "articles",
+        attributes: {},
+      });
+    });
+
+    it("should handle complex nested data", () => {
+      DataClassRegistry.registerObjectClass(mockModule as any, MockDataClass as any);
+
+      const complexData = {
+        title: "Test",
+        metadata: {
+          tags: ["tag1", "tag2"],
+          author: { name: "John", email: "john@example.com" },
+        },
+      };
+
+      const result = JsonApiDataFactory.create(mockModule as any, complexData);
+
+      expect(result.attributes).toEqual(complexData);
+    });
+  });
+});