@carlonicora/nextjs-jsonapi 1.77.3 → 1.78.0

package/src/features/assistant-message/data/__tests__/AssistantMessage.spec.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { AbstractApiData } from "../../../../core/abstracts/AbstractApiData";
+import { DataClassRegistry } from "../../../../core/registry/DataClassRegistry";
+import { ModuleRegistry } from "../../../../core/registry/ModuleRegistry";
+import { JsonApiHydratedDataInterface } from "../../../../core/interfaces/JsonApiHydratedDataInterface";
+import { ApiRequestDataTypeInterface } from "../../../../core/interfaces/ApiRequestDataTypeInterface";
+import { AssistantMessage } from "../AssistantMessage";
+
+// ---------------------------------------------------------------------------
+// Minimal test-only model — avoids collision with any real app module.
+// identifierFields = ["name"] resolves "Acme" from attributes.name.
+// ---------------------------------------------------------------------------
+class TestAccount extends AbstractApiData {
+  static identifierFields: string[] = ["name"];
+
+  rehydrate(data: JsonApiHydratedDataInterface): this {
+    super.rehydrate(data);
+    return this;
+  }
+
+  createJsonApi(_data?: any): any {
+    return {};
+  }
+}
+
+const testAccountModule: ApiRequestDataTypeInterface = {
+  name: "test-accounts",
+  model: TestAccount,
+} as any;
+
+// ---------------------------------------------------------------------------
+// Setup / teardown
+// ---------------------------------------------------------------------------
+const assistantMessageModule: ApiRequestDataTypeInterface = {
+  name: "assistant-messages",
+  model: AssistantMessage,
+} as any;
+
+const assistantModule: ApiRequestDataTypeInterface = {
+  name: "assistants",
+  model: class {},
+} as any;
+
+beforeAll(() => {
+  DataClassRegistry.clear();
+  DataClassRegistry.registerObjectClass(testAccountModule, TestAccount);
+  ModuleRegistry.register("TestAccount", testAccountModule);
+  ModuleRegistry.register("AssistantMessage", assistantMessageModule);
+  ModuleRegistry.register("Assistant", assistantModule);
+});
+
+afterAll(() => {
+  DataClassRegistry.clear();
+});
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function makeRehydratedMessage(jsonApiData: any, included: any[] = []): AssistantMessage {
+  const data: JsonApiHydratedDataInterface = {
+    jsonApi: jsonApiData,
+    included,
+  };
+  return new AssistantMessage().rehydrate(data);
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe("AssistantMessage.rehydrate", () => {
+  it("rehydrates `references` as an array of the correct Module's model", () => {
+    // GIVEN: JSON:API assistant-message with a `references` relationship pointing to
+    // a test-accounts entity, plus that entity in the `included` array.
+    const jsonApiData = {
+      id: "msg-1",
+      type: "assistant-messages",
+      attributes: {
+        role: "assistant",
+        content: "Here is the account.",
+        position: 1,
+      },
+      relationships: {
+        references: {
+          data: [{ type: "test-accounts", id: "acc-1" }],
+        },
+      },
+    };
+    const included = [
+      {
+        type: "test-accounts",
+        id: "acc-1",
+        attributes: { name: "Acme" },
+      },
+    ];
+
+    // WHEN
+    const message = makeRehydratedMessage(jsonApiData, included);
+
+    // THEN: references should contain one hydrated TestAccount instance
+    expect(message.references).toHaveLength(1);
+
+    const ref = message.references[0] as any;
+    // Type and id should be populated from the included entry
+    expect(ref.type).toBe("test-accounts");
+    expect(ref.id).toBe("acc-1");
+    // identifier reads from identifierFields = ["name"] → attributes.name = "Acme"
+    expect(ref.identifier).toBe("Acme");
+  });
+
+  it("returns an empty array when the relationship is absent", () => {
+    // GIVEN: JSON:API assistant-message with no `references` attribute or relationship
+    const jsonApiData = {
+      id: "msg-2",
+      type: "assistant-messages",
+      attributes: {
+        role: "user",
+        content: "Hello.",
+        position: 0,
+      },
+    };
+
+    // WHEN
+    const message = makeRehydratedMessage(jsonApiData, []);
+
+    // THEN
+    expect(message.references).toEqual([]);
+  });
+});
+
+describe("AssistantMessage.buildOptimistic", () => {
+  it("creates a user message with a tmp-prefixed id and the given content + position", () => {
+    const msg = AssistantMessage.buildOptimistic({
+      content: "hello",
+      assistantId: "a-1",
+      position: 3,
+    });
+
+    expect(msg.id.startsWith("tmp-")).toBe(true);
+    expect(msg.role).toBe("user");
+    expect(msg.content).toBe("hello");
+    expect(msg.position).toBe(3);
+  });
+
+  it("allows an omitted assistantId (first-message case)", () => {
+    const msg = AssistantMessage.buildOptimistic({ content: "first", position: 1 });
+
+    expect(msg.id.startsWith("tmp-")).toBe(true);
+    expect(msg.role).toBe("user");
+    expect(msg.content).toBe("first");
+    expect(msg.position).toBe(1);
+  });
+
+  it("produces distinct ids across successive calls", () => {
+    const a = AssistantMessage.buildOptimistic({ content: "x", position: 1 });
+    const b = AssistantMessage.buildOptimistic({ content: "x", position: 2 });
+    expect(a.id).not.toEqual(b.id);
+  });
+});

package/src/features/assistant-message/data/index.ts

@@ -0,0 +1,3 @@
+export * from "./AssistantMessage";
+export * from "./AssistantMessageInterface";
+export * from "./AssistantMessageService";

package/src/features/assistant-message/index.ts

@@ -0,0 +1,2 @@
+export * from "./AssistantMessageModule";
+export * from "./data";

package/src/features/user/contexts/CurrentUserContext.tsx

@@ -1,6 +1,5 @@
 "use client";
 
-import { getCookie } from "cookies-next";
 import { useAtom } from "jotai";
 import { atomWithStorage } from "jotai/utils";
 import { usePathname } from "next/navigation";
@@ -46,11 +45,6 @@ export const CurrentUserProvider = ({ children }: { children: React.ReactNode })
 
   const [dehydratedUser, setDehydratedUser] = useAtom(userAtom);
 
-  useEffect(() => {
-    const token = getCookie("token");
-    if (!token && dehydratedUser) setDehydratedUser(null);
-  }, [dehydratedUser, setDehydratedUser]);
-
   const matchUrlToModule = (_params?: { path: string }): ModuleWithPermissions | undefined => {
     const moduleKeys = Object.getOwnPropertyNames(Modules).filter(
       (key) => key !== "prototype" && key !== "_factory" && key !== "length" && key !== "name",
@@ -148,13 +142,9 @@ export const CurrentUserProvider = ({ children }: { children: React.ReactNode })
       try {
         const fullUser = await UserService.findFullUser();
         if (fullUser) {
-          const dehydrated = fullUser.dehydrate();
-
-          setDehydratedUser(dehydrated as any);
-          setUser(fullUser);
-
-          // Update authentication cookies with fresh user data
-          // Skip when triggered by WebSocket to prevent page reload (Server Actions modify cookies)
+          // Update authentication cookies with fresh user data BEFORE writing the atom,
+          // so downstream observers see cookies-then-user, never user-then-cookies.
+          // Skip when triggered by WebSocket to prevent page reload (Server Actions modify cookies).
           if (!options?.skipCookieUpdate) {
             await getTokenHandler()?.updateToken({
               userId: fullUser.id,
@@ -167,6 +157,8 @@ export const CurrentUserProvider = ({ children }: { children: React.ReactNode })
               })),
             });
           }
+
+          setDehydratedUser(fullUser.dehydrate() as any);
         }
       } catch (error) {
         console.error("Failed to refresh user data:", error);

package/src/features/user/contexts/__tests__/CurrentUserContext.spec.tsx

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render } from "@testing-library/react";
+
+vi.mock("cookies-next", () => ({
+  getCookie: vi.fn(() => undefined),
+}));
+
+vi.mock("next/navigation", () => ({
+  usePathname: () => "/",
+}));
+
+vi.mock("../../../../contexts/SocketContext", () => ({
+  useSocketContext: () => ({ socket: null, isConnected: false }),
+}));
+
+vi.mock("../../../../core", () => ({
+  Modules: { User: { name: "users" } },
+  rehydrate: (_module: unknown, data: any) => data,
+}));
+
+vi.mock("../../../../permissions", () => ({
+  Action: { Read: "read", Write: "write", Create: "create", Update: "update", Delete: "delete" },
+  checkPermissions: () => true,
+}));
+
+vi.mock("../../../../roles", () => ({
+  getRoleId: () => ({ Administrator: "admin" }),
+}));
+
+vi.mock("../../../auth/config", () => ({
+  getTokenHandler: vi.fn(() => ({
+    updateToken: vi.fn().mockResolvedValue(undefined),
+    removeToken: vi.fn().mockResolvedValue(undefined),
+  })),
+}));
+
+vi.mock("../../data", () => ({
+  UserService: {
+    findFullUser: vi.fn(),
+  },
+}));
+
+import { CurrentUserProvider, useCurrentUserContext } from "../CurrentUserContext";
+import { getCookie } from "cookies-next";
+import { getTokenHandler } from "../../../auth/config";
+import { UserService } from "../../data";
+
+function Consumer() {
+  const { currentUser } = useCurrentUserContext();
+  return <div data-testid="current-user-id">{currentUser ? (currentUser as { id: string }).id : "null"}</div>;
+}
+
+describe("CurrentUserProvider", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    vi.clearAllMocks();
+  });
+
+  it("keeps user hydrated from localStorage when token cookie is absent", async () => {
+    const storedUser = {
+      id: "user-1",
+      roles: [],
+      company: null,
+      modules: [],
+    };
+    localStorage.setItem("user", JSON.stringify(storedUser));
+    vi.mocked(getCookie).mockReturnValue(undefined);
+
+    const { getByTestId } = render(
+      <CurrentUserProvider>
+        <Consumer />
+      </CurrentUserProvider>,
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    expect(getByTestId("current-user-id").textContent).toBe("user-1");
+    expect(localStorage.getItem("user")).toBe(JSON.stringify(storedUser));
+  });
+
+  it("awaits updateToken before writing the user atom in refreshUser", async () => {
+    const oldUser = { id: "old", roles: [], company: null, modules: [] };
+    localStorage.setItem("user", JSON.stringify(oldUser));
+
+    const newDehydrated = { id: "new", roles: [], company: null, modules: [] };
+    const newFullUser = {
+      id: "new",
+      roles: [],
+      company: null,
+      modules: [],
+      dehydrate: () => newDehydrated,
+    };
+    vi.mocked(UserService.findFullUser).mockResolvedValue(newFullUser as any);
+
+    let resolveUpdateToken!: () => void;
+    const updateTokenPromise = new Promise<void>((resolve) => {
+      resolveUpdateToken = resolve;
+    });
+    const updateToken = vi.fn(async () => {
+      await updateTokenPromise;
+    });
+    vi.mocked(getTokenHandler).mockReturnValue({
+      updateToken,
+      removeToken: vi.fn().mockResolvedValue(undefined),
+    } as any);
+
+    let capturedRefreshUser: ((options?: { skipCookieUpdate?: boolean }) => Promise<void>) | undefined;
+    function InnerConsumer() {
+      const ctx = useCurrentUserContext();
+      capturedRefreshUser = ctx.refreshUser;
+      return (
+        <div data-testid="current-user-id">{ctx.currentUser ? (ctx.currentUser as { id: string }).id : "null"}</div>
+      );
+    }
+
+    const { getByTestId } = render(
+      <CurrentUserProvider>
+        <InnerConsumer />
+      </CurrentUserProvider>,
+    );
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(getByTestId("current-user-id").textContent).toBe("old");
+
+    expect(capturedRefreshUser).toBeDefined();
+    const refreshPromise = capturedRefreshUser!();
+
+    await Promise.resolve();
+    await Promise.resolve();
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    expect(updateToken).toHaveBeenCalledTimes(1);
+    expect(getByTestId("current-user-id").textContent).toBe("old");
+
+    resolveUpdateToken();
+    await refreshPromise;
+
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    expect(getByTestId("current-user-id").textContent).toBe("new");
+  });
+});

package/src/index.ts

@@ -46,3 +46,7 @@ export { showToast, showError, dismissToast, showCustomToast, type ToastOptions
 // RBAC feature (data + modules only; components via /components, hooks via /client)
 export * from "./features/rbac/data";
 export * from "./features/rbac/rbac.module";
+
+// Assistant + AssistantMessage feature data
+export * from "./features/assistant/data";
+export * from "./features/assistant-message/data";

package/dist/HowToInterface-BKhnkzBp.d.ts

@@ -1,17 +0,0 @@
-import { C as ContentInterface, a as ContentInput } from './notification.interface-DcSuc9CL.js';
-
-type BreadcrumbItemData = {
-    name: string;
-    href?: string;
-};
-
-type HowToInput = ContentInput & {
-    description?: any;
-    pages?: string | undefined | null;
-};
-interface HowToInterface extends ContentInterface {
-    get description(): any;
-    get pages(): string | undefined;
-}
-
-export type { BreadcrumbItemData as B, HowToInput as H, HowToInterface as a };

package/dist/HowToInterface-Cj8OuQFf.d.mts

@@ -1,17 +0,0 @@
-import { C as ContentInterface, a as ContentInput } from './notification.interface-DG6obXUH.mjs';
-
-type BreadcrumbItemData = {
-    name: string;
-    href?: string;
-};
-
-type HowToInput = ContentInput & {
-    description?: any;
-    pages?: string | undefined | null;
-};
-interface HowToInterface extends ContentInterface {
-    get description(): any;
-    get pages(): string | undefined;
-}
-
-export type { BreadcrumbItemData as B, HowToInput as H, HowToInterface as a };