@carlonicora/nextjs-jsonapi 1.110.0 → 1.111.1

package/scripts/generate-web-module/templates/table-hook.template.ts

@@ -5,7 +5,7 @@
  */
 
 import { FrontendTemplateData, FrontendField } from "../types/template-data.interface";
-import { toCamelCase } from "../transformers/name-transformer";
+import { toCamelCase, pluralize } from "../transformers/name-transformer";
 
 /**
  * Generate the table structure hook file content
@@ -96,7 +96,7 @@ registerTableGenerator(Modules.${names.pascalCase}, use${names.pascalCase}TableS
  * Generate field column map entries
  */
 function generateFieldColumnEntries(data: FrontendTemplateData): string {
-  const { names, fields, extendsContent } = data;
+  const { names, fields, extendsContent, relationships } = data;
   const entries: string[] = [];
 
   // Name field (with link and tooltip for tldr if Content-extending)
@@ -183,8 +183,37 @@ function generateFieldColumnEntries(data: FrontendTemplateData): string {
       enableSorting: false,
       enableHiding: false,
     }),`);
+    } else if (field.type === "date" || field.type === "datetime") {
+      entries.push(`    [${names.pascalCase}Fields.${field.name}]: () =>
+      cellDate({
+        name: "${field.name}",
+        title: t(\`features.${names.camelCase}.fields.${field.name}.label\`),
+      }),`);
     }
   });
 
+  // Relationship columns (rendered when flagged for table display)
+  relationships
+    .filter((rel) => rel.showInTable)
+    .forEach((rel) => {
+      const key = rel.single
+        ? toCamelCase(rel.alias || rel.variant || rel.name)
+        : pluralize(toCamelCase(rel.alias || rel.name));
+      const accessor = rel.single
+        ? `${names.camelCase}.${key}?.name ?? ""`
+        : `${names.camelCase}.${key}.map((r) => r.name).join(", ")`;
+      entries.push(`    [${names.pascalCase}Fields.${key}]: () => ({
+      id: "${key}",
+      accessorKey: "${key}",
+      header: t(\`generic.relationships.${key}.label\`),
+      cell: ({ row }: { row: TableContent<${names.pascalCase}Interface> }) => {
+        const ${names.camelCase}: ${names.pascalCase}Interface = row.original.jsonApiData;
+        return <span>{${accessor}}</span>;
+      },
+      enableSorting: false,
+      enableHiding: false,
+    }),`);
+    });
+
   return entries.join("\n");
 }

package/scripts/generate-web-module/transformers/import-resolver.ts

@@ -177,7 +177,6 @@ export interface ModuleFilePaths {
   selector: string;
   multiSelector: string;
   list: string;
-  details: string;
   content: string;
   container: string;
   listContainer: string;
@@ -220,7 +219,6 @@ export function buildFilePaths(
     selector: `${basePath}/components/forms/${names.pascalCase}Selector.tsx`,
     multiSelector: `${basePath}/components/forms/${names.pascalCase}MultiSelector.tsx`,
     list: `${basePath}/components/lists/${names.pascalCase}List.tsx`,
-    details: `${basePath}/components/details/${names.pascalCase}Details.tsx`,
     content: `${basePath}/components/details/${names.pascalCase}Content.tsx`,
     container: `${basePath}/components/containers/${names.pascalCase}Container.tsx`,
     listContainer: `${basePath}/components/containers/${names.pascalCase}ListContainer.tsx`,

package/scripts/generate-web-module/transformers/relationship-key.ts

@@ -0,0 +1,18 @@
+import { FrontendRelationship } from "../types/template-data.interface";
+import { toKebabCase, pluralize } from "./name-transformer";
+
+/** JSON:API wire key for a relationship. Schema dtoKey wins; otherwise derive
+ *  identically to the backend mapper so both sides of the wire agree. */
+export function resolveRelationshipKey(rel: FrontendRelationship): string {
+  if (rel.dtoKey) return rel.dtoKey;
+  // NOTE: Author relationships are normally NOT serialized through this helper — the backend
+  // special-cases Author via contextKey/currentUser and the model template skips Author
+  // serialization, so callers must not rely on this helper for Author wire keys.
+  if (rel.variant) {
+    return rel.single ? rel.variant.toLowerCase() : pluralize(rel.variant.toLowerCase());
+  }
+  if (rel.alias) {
+    return rel.single ? toKebabCase(rel.alias) : pluralize(toKebabCase(rel.alias));
+  }
+  return rel.single ? rel.name.toLowerCase() : pluralize(rel.name.toLowerCase());
+}

package/scripts/generate-web-module/transformers/relationship-resolver.ts

@@ -122,6 +122,8 @@ export function resolveRelationship(rel: JsonRelationshipDefinition, targetHasNa
     modelKebab,
     fields,
     targetHasName: targetHasNameMap?.get(rel.name) ?? true, // Foundation entities default to true
+    dtoKey: rel.dtoKey ?? "",
+    showInTable: rel.showInTable === true,
   };
 }
 

package/scripts/generate-web-module/types/json-schema.interface.ts

@@ -13,6 +13,7 @@ export interface JsonFieldDefinition {
   name: string;
   type: string;
   nullable: boolean;
+  readOnly?: boolean;
 }
 
 /**
@@ -29,6 +30,10 @@ export interface JsonRelationshipDefinition {
   toNode: boolean; // Backend-specific, ignored in frontend
   nullable: boolean;
   fields?: JsonFieldDefinition[]; // Relationship property fields (stored on edges)
+  /** Explicit JSON:API wire key. When absent it is derived identically to the backend mapper. */
+  dtoKey?: string;
+  description?: string;
+  showInTable?: boolean;
 }
 
 /**
@@ -44,4 +49,8 @@ export interface JsonModuleDefinition {
   relationships: JsonRelationshipDefinition[];
   /** Explicitly set whether this module extends Content. If not set, auto-detects based on fields. */
   extendsContent?: boolean;
+  featureId?: string;
+  displayProp?: string;
+  containerTabs?: { activity?: boolean; relations?: { module: string; listProp: string; directory: string }[] };
+  inclusions?: { related?: { endpoint: string; fields: string[] }[] };
 }

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

@@ -30,6 +30,7 @@ export interface FrontendField {
   formComponent: FormComponentType;
   nullable: boolean;
   isContentField: boolean; // Indicates BlockNoteEditor
+  readOnly?: boolean;
 }
 
 /**
@@ -68,6 +69,8 @@ export interface FrontendRelationship {
   modelKebab: string; // e.g., "user"
   fields?: FrontendField[]; // Relationship property fields (stored on edges)
   targetHasName: boolean; // Whether the target entity has a "name" field (or extends Content)
+  dtoKey: string;       // resolved wire key; "" means derive at use-site
+  showInTable: boolean;
 }
 
 /**
@@ -153,6 +156,10 @@ export interface FrontendTemplateData {
 
   // For service generation
   relationshipServiceMethods: RelationshipServiceMethod[];
+  featureId?: string;
+  displayProp: string;
+  containerTabs: { activity: boolean; relations: { module: string; listProp: string; directory: string }[] };
+  relatedInclusions: { endpoint: string; fields: string[] }[];
 }
 
 /**

package/src/features/notification/components/modals/NotificationModal.tsx

@@ -36,7 +36,6 @@ function NotificationModalContent({ isOpen, setIsOpen }: NotificationModalProps)
     error,
     loadNotifications,
     shouldRefresh,
-    lastLoaded,
   } = useNotificationContext();
   const {
     socketNotifications,
@@ -87,10 +86,8 @@ function NotificationModalContent({ isOpen, setIsOpen }: NotificationModalProps)
     setNewNotifications(unreadCount > 0);
   }, [unreadCount]);
 
-  // Load notifications from API on mount if never loaded
-  useEffect(() => {
-    if (lastLoaded === 0) loadNotifications();
-  }, [lastLoaded, loadNotifications]);
+  // The initial load is owned by NotificationContextProvider's mount effect.
+  // The bell still refreshes on open when the cache is stale (see handleOpenChange).
 
   const processSocketNotificationsRef = useRef<NodeJS.Timeout | null>(null);
 

package/src/features/notification/contexts/NotificationContext.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { useTranslations } from "next-intl";
-import React, { createContext, ReactElement, useCallback, useContext, useEffect, useState } from "react";
+import React, { createContext, ReactElement, useCallback, useContext, useEffect, useRef, useState } from "react";
 import { SharedProvider } from "../../../contexts";
 import { Modules } from "../../../core";
 import { useI18nRouter } from "../../../i18n";
@@ -55,6 +55,11 @@ export const NotificationContextProvider = ({ children }: NotificationContextPro
   const [lastLoaded, setLastLoaded] = useState(0);
   const [hasInitiallyLoaded, setHasInitiallyLoaded] = useState(false);
 
+  // Tracks an in-flight loadNotifications() request so concurrent callers
+  // (the provider's mount effect + any consumer that also loads on mount)
+  // share a single GET /notifications instead of each firing their own.
+  const inFlightRef = useRef<Promise<void> | null>(null);
+
   // Access current user for initial load check
   const { currentUser } = useCurrentUserContext();
 
@@ -80,19 +85,30 @@ export const NotificationContextProvider = ({ children }: NotificationContextPro
   }, []);
 
   const loadNotifications = useCallback(async () => {
-    setIsLoading(true);
-    setError(null);
+    // Coalesce concurrent callers into one request. Without this, the several
+    // mount-time loaders fire before the first fetch resolves (lastLoaded is
+    // still 0), so each issues its own GET /notifications.
+    if (inFlightRef.current) return inFlightRef.current;
+
+    const request = (async () => {
+      setIsLoading(true);
+      setError(null);
+
+      try {
+        const fetchedNotifications = await NotificationService.findMany({});
+        setNotifications(fetchedNotifications);
+        setLastLoaded(Date.now());
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : "Failed to load notifications";
+        setError(errorMessage);
+      } finally {
+        setIsLoading(false);
+        inFlightRef.current = null;
+      }
+    })();
 
-    try {
-      const fetchedNotifications = await NotificationService.findMany({});
-      setNotifications(fetchedNotifications);
-      setLastLoaded(Date.now());
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : "Failed to load notifications";
-      setError(errorMessage);
-    } finally {
-      setIsLoading(false);
-    }
+    inFlightRef.current = request;
+    return request;
   }, []);
 
   // Initial load - runs once per session when user is available and not admin

package/src/features/notification/contexts/__tests__/NotificationContext.spec.tsx

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, beforeAll, beforeEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { configureI18n } from "../../../../i18n";
+
+// currentUser undefined → the provider's initial-load effect is a no-op
+// (it returns early on `!currentUser`), so the ONLY fetches in this test come
+// from the explicit loadNotifications() calls below. This isolates the
+// in-flight de-duplication behaviour from the mount-time auto-load.
+vi.mock("../../../user/contexts/CurrentUserContext", () => ({
+  useCurrentUserContext: () => ({ currentUser: undefined }),
+}));
+vi.mock("../../data/notification.service", () => ({
+  NotificationService: { findMany: vi.fn(), markAsRead: vi.fn() },
+}));
+
+import { NotificationContextProvider, useNotificationContext } from "../NotificationContext";
+import { NotificationService } from "../../data/notification.service";
+
+const stubRouter = {
+  push: vi.fn(),
+  replace: vi.fn(),
+  back: vi.fn(),
+  forward: vi.fn(),
+  refresh: vi.fn(),
+  prefetch: vi.fn(),
+};
+
+function wrapper({ children }: { children: React.ReactNode }) {
+  return <NotificationContextProvider>{children}</NotificationContextProvider>;
+}
+
+describe("NotificationContext.loadNotifications", () => {
+  beforeAll(() => {
+    // useI18nRouter() throws unless i18n is configured; the provider calls it at mount.
+    configureI18n({
+      useRouter: () => stubRouter,
+      useTranslations: () => (key: string) => key,
+      usePathname: () => "/",
+      Link: (({ children }: { children: React.ReactNode }) => children) as any,
+    });
+  });
+
+  beforeEach(() => {
+    vi.mocked(NotificationService.findMany).mockReset();
+  });
+
+  it("coalesces concurrent loadNotifications calls into a single request", async () => {
+    let release: (() => void) | undefined;
+    vi.mocked(NotificationService.findMany).mockImplementation(
+      () =>
+        new Promise((resolve) => {
+          release = () => resolve([] as never);
+        }),
+    );
+
+    const { result } = renderHook(() => useNotificationContext(), { wrapper });
+
+    // Three concurrent callers, mirroring the three mount-time triggers
+    // (provider + LayoutDetails + NotificationModal) firing before the first
+    // request resolves.
+    await act(async () => {
+      result.current.loadNotifications();
+      result.current.loadNotifications();
+      result.current.loadNotifications();
+      release?.();
+    });
+
+    expect(NotificationService.findMany).toHaveBeenCalledTimes(1);
+  });
+});