@carlonicora/nextjs-jsonapi 1.110.0 → 1.111.1

package/scripts/generate-web-module/__tests__/container.spec.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect } from "vitest";
+import { makeFrontendData } from "./fixtures";
+import { generateContainerTemplate } from "../templates/components/container.template";
+import { generateListContainerTemplate } from "../templates/components/list-container.template";
+import { generateContentTemplate } from "../templates/components/content.template";
+
+describe("container template", () => {
+  it("uses RoundPageContainer with tabs and id, not details prop, and renders Content", () => {
+    const out = generateContainerTemplate(makeFrontendData());
+    expect(out).toContain("tabs: Tab[]");
+    expect(out).toContain("id={widget.id}");
+    expect(out).not.toContain("details={");
+    expect(out).not.toContain("WidgetDetails");
+    expect(out).toContain("<WidgetContent widget={widget} />");
+  });
+
+  it("emits an Activity tab by default and no Tasks tab", () => {
+    const out = generateContainerTemplate(makeFrontendData());
+    expect(out).toContain("<ActivityFeed module={Modules.Widget} entityId={widget.id} />");
+    expect(out).not.toContain("TaskProvider");
+  });
+
+  it("omits the Activity tab when containerTabs.activity is false", () => {
+    const out = generateContainerTemplate(makeFrontendData({ containerTabs: { activity: false, relations: [] } }));
+    expect(out).not.toContain("ActivityFeed");
+  });
+
+  it("emits a relation tab when containerTabs.relations has an entry", () => {
+    const out = generateContainerTemplate(makeFrontendData({
+      containerTabs: { activity: true, relations: [{ module: "Quote", listProp: "widget", directory: "sales" }] },
+    }));
+    expect(out).toContain('import QuoteList from "@/features/sales/quote/components/lists/QuoteList"');
+    expect(out).toContain("key: Modules.Quote");
+    expect(out).toContain("<QuoteList widget={widget} />");
+  });
+
+  it("gates default export on hasPermissionToModule", () => {
+    const out = generateContainerTemplate(makeFrontendData());
+    expect(out).toContain("hasPermissionToModule({ module: Modules.Widget, action: Action.Delete, data: widget })");
+  });
+});
+
+describe("list-container template", () => {
+  it("always renders fullWidth", () => {
+    const out = generateListContainerTemplate(makeFrontendData());
+    expect(out).toContain("<RoundPageContainer module={Modules.Widget} fullWidth>");
+    expect(out).toContain("<WidgetList fullWidth />");
+  });
+});
+
+describe("content template", () => {
+  it("is always generated (returns a string) and renders AttributeElement", () => {
+    const out = generateContentTemplate(makeFrontendData());
+    expect(typeof out).toBe("string");
+    expect(out).toContain("export function WidgetContent");
+    expect(out).toContain("AttributeElement");
+  });
+});

package/scripts/generate-web-module/__tests__/data-service.spec.ts

@@ -0,0 +1,18 @@
+import { describe, it, expect } from "vitest";
+import { makeFrontendData } from "./fixtures";
+import { generateServiceTemplate } from "../templates/data/service.template";
+
+describe("frontend data service template", () => {
+  it("applies inclusions inside findOne", () => {
+    const out = generateServiceTemplate(makeFrontendData());
+    const findOne = out.split("static async findOne")[1].split("static async")[0];
+    expect(findOne).toContain("limitToFields");
+    expect(findOne).toContain("limitToType");
+  });
+
+  it("emits a patch method", () => {
+    const out = generateServiceTemplate(makeFrontendData());
+    expect(out).toContain("static async patch(params: { id: string } & Partial<Omit<WidgetInput, \"id\">>)");
+    expect(out).toContain("method: HttpMethod.PATCH");
+  });
+});

package/scripts/generate-web-module/__tests__/editor.spec.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "vitest";
+import { makeFrontendData } from "./fixtures";
+import { generateEditorTemplate } from "../templates/components/editor.template";
+
+describe("editor template — EditorSheet", () => {
+  it("uses EditorSheet and not the legacy Dialog stack", () => {
+    const out = generateEditorTemplate(makeFrontendData());
+    expect(out).toContain("EditorSheet");
+    expect(out).not.toContain("CommonEditorButtons");
+    expect(out).not.toContain("CommonEditorDiscardDialog");
+    expect(out).not.toContain("useEditorDialog");
+    expect(out).not.toMatch(/DialogContent/);
+  });
+
+  it("gates the default export on hasPermissionToModule", () => {
+    const out = generateEditorTemplate(makeFrontendData());
+    expect(out).toContain("useCurrentUserContext");
+    expect(out).toContain("hasPermissionToModule({ module: Modules.Widget, action, data: props.widget })");
+  });
+
+  it("wraps formSchema in useMemo and defaults in useCallback", () => {
+    const out = generateEditorTemplate(makeFrontendData());
+    expect(out).toContain("const formSchema = useMemo(");
+    expect(out).toContain("const getDefaultValues = useCallback(");
+  });
+
+  it("passes EditorSheet lifecycle props and onSubmit returns the saved entity", () => {
+    const out = generateEditorTemplate(makeFrontendData());
+    expect(out).toContain("onRevalidate={revalidatePaths}");
+    expect(out).toContain("onReset={getDefaultValues}");
+    expect(out).toContain("module={Modules.Widget}");
+    // onSubmit returns the service result (no manual setOpen/errorToast)
+    expect(out).not.toContain("setOpen(false)");
+    expect(out).not.toContain("errorToast(");
+  });
+});

package/scripts/generate-web-module/__tests__/fixtures.ts

@@ -0,0 +1,43 @@
+import { FrontendRelationship, FrontendTemplateData } from "../types/template-data.interface";
+
+export function makeRelationship(o: Partial<FrontendRelationship> = {}): FrontendRelationship {
+  return {
+    name: "Account", variant: undefined, alias: undefined, directory: "crm",
+    single: true, nullable: false, isFoundation: false,
+    formFieldId: "account", formFieldIdPlural: "accounts", payloadFieldId: "accountId",
+    selectorComponent: "AccountSelector", zodSchema: "entityObjectSchema",
+    importPath: "@/features/crm/account/components/forms/AccountSelector",
+    interfaceImportPath: "@/features/crm/account/data/AccountInterface",
+    serviceImportPath: "@/features/crm/account/data/AccountService",
+    interfaceName: "AccountInterface", modelKebab: "account",
+    fields: undefined, targetHasName: true, dtoKey: "", showInTable: false,
+    ...o,
+  };
+}
+
+export function makeFrontendData(o: Partial<FrontendTemplateData> = {}): FrontendTemplateData {
+  return {
+    names: {
+      pascalCase: "Widget", camelCase: "widget", kebabCase: "widget",
+      pluralPascal: "Widgets", pluralCamel: "widgets", pluralKebab: "widgets",
+      titleCase: "Widget", pluralTitleCase: "Widgets",
+    },
+    moduleId: "00000000-0000-4000-a000-000000000001",
+    endpoint: "widgets", targetDir: "features/demo", importTargetDir: "demo",
+    extendsContent: false,
+    fields: [
+      { name: "name", type: "string", tsType: "string", zodSchema: "z.string()", formComponent: "FormInput", nullable: false, isContentField: false },
+      { name: "due_date", type: "date", tsType: "Date", zodSchema: "z.date().optional()", formComponent: "DatePicker", nullable: true, isContentField: false },
+    ],
+    relationships: [],
+    i18nKeys: { moduleName: "widget", fields: {}, relationships: {}, type: { singular: "Widget", plural: "Widgets", icuPlural: "" } },
+    imports: { models: [], selectors: [], library: [] },
+    tableFieldNames: [],
+    relationshipServiceMethods: [],
+    featureId: undefined,
+    displayProp: "name",
+    containerTabs: { activity: true, relations: [] },
+    relatedInclusions: [],
+    ...o,
+  };
+}

package/scripts/generate-web-module/__tests__/model-interface.spec.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from "vitest";
+import { makeFrontendData, makeRelationship } from "./fixtures";
+import { generateModelTemplate } from "../templates/data/model.template";
+import { generateInterfaceTemplate } from "../templates/data/interface.template";
+
+describe("model template — dates", () => {
+  it("imports formatLocalDate and uses it for date fields in createJsonApi", () => {
+    const out = generateModelTemplate(makeFrontendData());
+    expect(out).toContain("formatLocalDate");
+    expect(out).toContain("response.data.attributes.due_date = formatLocalDate(data.due_date)");
+  });
+});
+
+describe("model template — relationship wire keys", () => {
+  it("uses dtoKey verbatim for rehydrate and createJsonApi", () => {
+    const out = generateModelTemplate(makeFrontendData({
+      relationships: [makeRelationship({ name: "PipelineStage", single: true, dtoKey: "pipelinestage", interfaceName: "PipelineStageInterface", modelKebab: "pipeline-stage", selectorComponent: "PipelineStageSelector", interfaceImportPath: "@/features/crm/pipeline-stage/data/PipelineStageInterface" })],
+    }));
+    expect(out).toContain('"pipelinestage"');
+    expect(out).toContain("response.data.relationships.pipelinestage");
+  });
+
+  it("emits per-item meta array for many-with-edge-fields", () => {
+    const out = generateModelTemplate(makeFrontendData({
+      relationships: [makeRelationship({
+        name: "Item", single: false, dtoKey: "estimateitems", alias: "EstimateItem",
+        interfaceName: "ItemInterface", modelKebab: "item", selectorComponent: "ItemMultiSelector",
+        interfaceImportPath: "@/features/plm/item/data/ItemInterface",
+        fields: [{ name: "quantity", type: "number", tsType: "number", zodSchema: "z.number()", formComponent: "FormInputNumber", nullable: false, isContentField: false }],
+      })],
+    }));
+    expect(out).toContain("data.estimateItemMeta?.find");
+    expect(out).toContain("response.data.relationships.estimateitems");
+  });
+
+  it("model references and imports the named RelationshipMeta interface", () => {
+    const out = generateModelTemplate(makeFrontendData({
+      relationships: [makeRelationship({
+        name: "Item", single: false, dtoKey: "estimateitems", alias: "EstimateItem",
+        interfaceName: "ItemInterface", modelKebab: "item", selectorComponent: "ItemMultiSelector",
+        interfaceImportPath: "@/features/plm/item/data/ItemInterface",
+        fields: [{ name: "quantity", type: "number", tsType: "number", zodSchema: "z.number()", formComponent: "FormInputNumber", nullable: false, isContentField: false }],
+      })],
+    }));
+    expect(out).toContain("EstimateItemRelationshipMeta");
+    expect(out).toContain("ItemInterface & EstimateItemRelationshipMeta");
+    // imported from the module's own interface file (Widget)
+    expect(out).toMatch(/import \{[^}]*EstimateItemRelationshipMeta[^}]*\} from "@\/features\/demo\/widget\/data\/WidgetInterface"/);
+  });
+});
+
+describe("interface template", () => {
+  it("emits a named RelationshipMeta interface and a meta array in Input", () => {
+    const out = generateInterfaceTemplate(makeFrontendData({
+      relationships: [makeRelationship({
+        name: "Item", single: false, dtoKey: "estimateitems", alias: "EstimateItem",
+        interfaceName: "ItemInterface", modelKebab: "item",
+        interfaceImportPath: "@/features/plm/item/data/ItemInterface",
+        fields: [{ name: "quantity", type: "number", tsType: "number", zodSchema: "z.number()", formComponent: "FormInputNumber", nullable: false, isContentField: false }],
+      })],
+    }));
+    expect(out).toContain("export interface EstimateItemRelationshipMeta");
+    expect(out).toContain("estimateItemMeta?:");
+  });
+
+  it("keeps readOnly fields in the interface but out of Input", () => {
+    const out = generateInterfaceTemplate(makeFrontendData({
+      fields: [
+        { name: "name", type: "string", tsType: "string", zodSchema: "z.string()", formComponent: "FormInput", nullable: false, isContentField: false },
+        { name: "effective_value", type: "number", tsType: "number", zodSchema: "z.number()", formComponent: "FormInputNumber", nullable: true, isContentField: false, readOnly: true },
+      ],
+    }));
+    expect(out).toContain("get effective_value()");
+    const inputBlock = out.split("Input = {")[1].split("};")[0];
+    expect(inputBlock).not.toContain("effective_value");
+  });
+});

package/scripts/generate-web-module/__tests__/plumbing.spec.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from "vitest";
+import { makeFrontendData, makeRelationship } from "./fixtures";
+import { resolveRelationshipKey } from "../transformers/relationship-key";
+
+describe("frontend plumbing", () => {
+  it("defaults displayProp to name and activity tab on", () => {
+    const d = makeFrontendData();
+    expect(d.displayProp).toBe("name");
+    expect(d.containerTabs.activity).toBe(true);
+  });
+
+  it("resolves wire key from explicit dtoKey verbatim", () => {
+    expect(resolveRelationshipKey(makeRelationship({ dtoKey: "estimateitems" }))).toBe("estimateitems");
+  });
+
+  it("derives wire key identically to the backend when dtoKey absent", () => {
+    expect(resolveRelationshipKey(makeRelationship({ name: "Account", single: true }))).toBe("account");
+    expect(resolveRelationshipKey(makeRelationship({ name: "Person", single: false }))).toBe("persons");
+    expect(resolveRelationshipKey(makeRelationship({ alias: "EstimateItem", single: false }))).toBe("estimate-items");
+  });
+});

package/scripts/generate-web-module/__tests__/selector.spec.ts

@@ -0,0 +1,24 @@
+import { describe, it, expect } from "vitest";
+import { makeFrontendData } from "./fixtures";
+import { generateSelectorTemplate } from "../templates/components/selector.template";
+
+describe("selector template — combobox style", () => {
+  it("uses Button combobox trigger + Command primitives + Loader2", () => {
+    const out = generateSelectorTemplate(makeFrontendData());
+    expect(out).toContain('role="combobox"');
+    expect(out).toContain("ChevronsUpDown");
+    expect(out).toContain("CommandInput");
+    expect(out).toContain("CommandEmpty");
+    expect(out).toContain("CommandGroup");
+    expect(out).toContain("Loader2");
+    expect(out).toContain("w-(--radix-popover-trigger-width) p-0");
+  });
+
+  it("drops the legacy bespoke styling", () => {
+    const out = generateSelectorTemplate(makeFrontendData());
+    expect(out).not.toContain("CircleX");
+    expect(out).not.toContain("RefreshCwIcon");
+    expect(out).not.toContain("SearchIcon");
+    expect(out).not.toContain("bg-input/20");
+  });
+});

package/scripts/generate-web-module/__tests__/table-module-list.spec.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest";
+import { makeFrontendData, makeRelationship } from "./fixtures";
+import { generateTableHookTemplate } from "../templates/table-hook.template";
+import { generateModuleTemplate } from "../templates/module.template";
+import { generateListTemplate } from "../templates/components/list.template";
+
+describe("table-hook template", () => {
+  it("emits cellDate for date fields", () => {
+    const out = generateTableHookTemplate(makeFrontendData());
+    expect(out).toContain("[WidgetFields.due_date]");
+    expect(out).toContain("cellDate({");
+  });
+
+  it("emits a relationship column when showInTable", () => {
+    const out = generateTableHookTemplate(makeFrontendData({
+      relationships: [makeRelationship({ name: "Account", single: true, showInTable: true })],
+    }));
+    expect(out).toContain("widget.account?.name");
+  });
+
+  it("uses variant for single-relationship column key when no alias", () => {
+    const out = generateTableHookTemplate(makeFrontendData({
+      relationships: [makeRelationship({ name: "User", variant: "Author", single: true, showInTable: true })],
+    }));
+    expect(out).toContain("WidgetFields.author");
+    expect(out).not.toContain("WidgetFields.user]");
+  });
+
+  it("emits a many relationship column joined by name", () => {
+    const out = generateTableHookTemplate(makeFrontendData({
+      relationships: [makeRelationship({ name: "Tag", single: false, showInTable: true })],
+    }));
+    expect(out).toContain("WidgetFields.tags");
+    expect(out).toContain('.map((r) => r.name).join(", ")');
+  });
+});
+
+describe("module template", () => {
+  it("emits feature when featureId set", () => {
+    const out = generateModuleTemplate(makeFrontendData({ featureId: "Crm" }));
+    expect(out).toContain('import { FeatureIds } from "@/enums/feature.ids"');
+    expect(out).toContain("feature: FeatureIds.Crm");
+  });
+
+  it("emits cross-module inclusions", () => {
+    const out = generateModuleTemplate(makeFrontendData({
+      relatedInclusions: [{ endpoint: "accounts", fields: ["name", "image"] }],
+    }));
+    expect(out).toContain('createJsonApiInclusion("accounts", [`name`, `image`])');
+  });
+});
+
+describe("list template", () => {
+  it("forwards fullWidth to ContentListTable", () => {
+    const out = generateListTemplate(makeFrontendData());
+    expect(out).toContain("fullWidth");
+    expect(out).toContain("fullWidth={fullWidth}");
+  });
+});

package/scripts/generate-web-module/generator.ts

@@ -12,7 +12,6 @@ import {
   generateContextTemplate,
   generateDeleterTemplate,
   generateDetailPageTemplate,
-  generateDetailsTemplate,
   generateEditorTemplate,
   generateFieldsTemplate,
   generateAliasesTemplate,
@@ -186,6 +185,10 @@ function buildTemplateData(schema: JsonModuleDefinition, targetHasNameMap?: Map<
 
   // Map fields
   const allFields = mapFields(schema.fields, names.camelCase);
+  allFields.forEach((f) => {
+    const src = schema.fields.find((sf) => sf.name === f.name);
+    f.readOnly = src?.readOnly === true;
+  });
 
   // Get inherited fields to filter out for forms (Content fields are handled specially)
   const inheritedFields = extendsContent ? ["name", "tldr", "abstract", "content"] : [];
@@ -234,6 +237,13 @@ function buildTemplateData(schema: JsonModuleDefinition, targetHasNameMap?: Map<
     imports,
     tableFieldNames,
     relationshipServiceMethods,
+    featureId: schema.featureId,
+    displayProp: schema.displayProp ?? (allFields.some((f) => f.name === "name") ? "name" : "id"),
+    containerTabs: {
+      activity: schema.containerTabs?.activity !== false,
+      relations: schema.containerTabs?.relations ?? [],
+    },
+    relatedInclusions: schema.inclusions?.related ?? [],
   };
 }
 
@@ -338,22 +348,13 @@ function generateAllFiles(data: FrontendTemplateData, schema: JsonModuleDefiniti
     type: "component",
   });
 
+  // Content component — always emitted (Details tab body)
   files.push({
-    path: paths.details,
-    content: generateDetailsTemplate(data),
+    path: paths.content,
+    content: generateContentTemplate(data),
     type: "component",
   });
 
-  // Content component only for Content-extending modules
-  const contentTemplate = generateContentTemplate(data);
-  if (contentTemplate) {
-    files.push({
-      path: paths.content,
-      content: contentTemplate,
-      type: "component",
-    });
-  }
-
   files.push({
     path: paths.container,
     content: generateContainerTemplate(data),

package/scripts/generate-web-module/templates/components/container.template.ts

@@ -1,9 +1,14 @@
 /**
  * Container Template
  *
- * Generates {Module}Container.tsx component for displaying item detail page.
+ * Generates {Module}Container.tsx component for the item detail page.
+ *
+ * Emits a RoundPageContainer driven by a `tabs` array: a default "Details" tab
+ * rendering {Module}Content, one tab per configured relation list, and an
+ * optional "Activity" tab. The default export gates on delete permission.
  */
 
+import { pluralize, toCamelCase, toKebabCase } from "../../transformers/name-transformer";
 import { FrontendTemplateData } from "../../types/template-data.interface";
 
 /**
@@ -13,86 +18,66 @@ import { FrontendTemplateData } from "../../types/template-data.interface";
  * @returns Generated file content
  */
 export function generateContainerTemplate(data: FrontendTemplateData): string {
-  const { names, extendsContent } = data;
-
-  // Content-extending modules get full tabs with relevant content/users
-  if (extendsContent) {
-    return generateContentContainerTemplate(data);
+  const { names, containerTabs } = data;
+  const camel = names.camelCase;
+
+  const relationImports: string[] = [];
+  const relationTabs: string[] = [];
+  for (const rel of containerTabs.relations) {
+    const relKebab = toKebabCase(rel.module);
+    const relPluralCamel = pluralize(toCamelCase(rel.module));
+    relationImports.push(
+      `import ${rel.module}List from "@/features/${rel.directory}/${relKebab}/components/lists/${rel.module}List";`,
+    );
+    relationTabs.push(
+      `    {\n      key: Modules.${rel.module},\n      label: t(\`entities.${relPluralCamel.toLowerCase()}\`, { count: 2 }),\n      content: <${rel.module}List ${rel.listProp}={${camel}} />,\n    },`,
+    );
   }
 
-  // Non-content modules get simpler container
-  return generateSimpleContainerTemplate(data);
-}
+  const tabEntries: string[] = [
+    `    {\n      label: "Details",\n      content: <${names.pascalCase}Content ${camel}={${camel}} />,\n    },`,
+    ...relationTabs,
+  ];
 
-/**
- * Generate container for Content-extending modules
- */
-function generateContentContainerTemplate(data: FrontendTemplateData): string {
-  const { names } = data;
+  if (containerTabs.activity) {
+    tabEntries.push(
+      `    {\n      label: "Activity",\n      content: <ActivityFeed module={Modules.${names.pascalCase}} entityId={${camel}.id} />,\n    },`,
+    );
+  }
+
+  const activityImport = containerTabs.activity
+    ? `import ActivityFeed from "@/features/activity/activity-feed/components/ActivityFeed";\n`
+    : "";
+  const relationImportBlock = relationImports.length ? `${relationImports.join("\n")}\n` : "";
 
   return `"use client";
 
-import ${names.pascalCase}Content from "@/features/${data.importTargetDir}/${names.kebabCase}/components/details/${names.pascalCase}Content";
-import ${names.pascalCase}Details from "@/features/${data.importTargetDir}/${names.kebabCase}/components/details/${names.pascalCase}Details";
+${activityImport}${relationImportBlock}import { ${names.pascalCase}Content } from "@/features/${data.importTargetDir}/${names.kebabCase}/components/details/${names.pascalCase}Content";
 import { use${names.pascalCase}Context } from "@/features/${data.importTargetDir}/${names.kebabCase}/contexts/${names.pascalCase}Context";
 import { ${names.pascalCase}Interface } from "@/features/${data.importTargetDir}/${names.kebabCase}/data/${names.pascalCase}Interface";
-import { RoundPageContainer } from "@carlonicora/nextjs-jsonapi/components";
-import { Modules } from "@carlonicora/nextjs-jsonapi/core";
+import { RoundPageContainer, Tab } from "@carlonicora/nextjs-jsonapi/components";
+import { useCurrentUserContext } from "@carlonicora/nextjs-jsonapi/contexts";
+import { Action, Modules } from "@carlonicora/nextjs-jsonapi/core";
+import { useTranslations } from "next-intl";
 
-type ${names.pascalCase}ContainerProps = {
-  ${names.camelCase}: ${names.pascalCase}Interface;
-};
+type ${names.pascalCase}ContainerProps = { ${camel}: ${names.pascalCase}Interface };
 
-function ${names.pascalCase}ContainerInternal({ ${names.camelCase} }: ${names.pascalCase}ContainerProps) {
-  return (
-    <RoundPageContainer module={Modules.${names.pascalCase}} details={<${names.pascalCase}Details />}>
-      <${names.pascalCase}Content />
-    </RoundPageContainer>
-  );
-}
+function ${names.pascalCase}ContainerInternal({ ${camel} }: ${names.pascalCase}ContainerProps) {
+  const t = useTranslations();
 
-export default function ${names.pascalCase}Container() {
-  const { ${names.camelCase} } = use${names.pascalCase}Context();
-  if (!${names.camelCase}) return null;
+  const tabs: Tab[] = [
+${tabEntries.join("\n")}
+  ];
 
-  return <${names.pascalCase}ContainerInternal ${names.camelCase}={${names.camelCase}} />;
-}
-`;
-}
-
-/**
- * Generate container for non-Content modules
- */
-function generateSimpleContainerTemplate(data: FrontendTemplateData): string {
-  const { names } = data;
-
-  return `"use client";
-
-import ${names.pascalCase}Details from "@/features/${data.importTargetDir}/${names.kebabCase}/components/details/${names.pascalCase}Details";
-import { use${names.pascalCase}Context } from "@/features/${data.importTargetDir}/${names.kebabCase}/contexts/${names.pascalCase}Context";
-import { ${names.pascalCase}Interface } from "@/features/${data.importTargetDir}/${names.kebabCase}/data/${names.pascalCase}Interface";
-import { RoundPageContainer } from "@carlonicora/nextjs-jsonapi/components";
-import { Modules } from "@carlonicora/nextjs-jsonapi/core";
-
-type ${names.pascalCase}ContainerProps = {
-  ${names.camelCase}: ${names.pascalCase}Interface;
-};
-
-function ${names.pascalCase}ContainerInternal({ ${names.camelCase} }: ${names.pascalCase}ContainerProps) {
-  return (
-    <RoundPageContainer module={Modules.${names.pascalCase}} details={<${names.pascalCase}Details />}>
-      <div className="flex w-full flex-col gap-y-4">
-        {/* Add custom content sections here */}
-      </div>
-    </RoundPageContainer>
-  );
+  return <RoundPageContainer module={Modules.${names.pascalCase}} id={${camel}.id} tabs={tabs} />;
 }
 
 export default function ${names.pascalCase}Container() {
-  const { ${names.camelCase} } = use${names.pascalCase}Context();
-  if (!${names.camelCase}) return null;
-
-  return <${names.pascalCase}ContainerInternal ${names.camelCase}={${names.camelCase}} />;
+  const { hasPermissionToModule } = useCurrentUserContext();
+  const { ${camel} } = use${names.pascalCase}Context();
+  if (!${camel}) return null;
+  if (!hasPermissionToModule({ module: Modules.${names.pascalCase}, action: Action.Delete, data: ${camel} })) return null;
+  return <${names.pascalCase}ContainerInternal ${camel}={${camel}} />;
 }
 `;
 }