@atlashub/smartstack-cli 4.34.0 → 4.36.0

package/templates/skills/application/templates-frontend.md

@@ -2,8 +2,8 @@
 
 > These templates generate React/TypeScript code for new applications/modules.
 
-> **DEPRECATED (v3.7+):** Pattern A (mergeRoutes) and Pattern B (JSX Routes) below
-> are replaced by PageRegistry.register() + DynamicRouter.
+> **v3.7+:** Pattern A (mergeRoutes) and Pattern B (JSX Routes) were removed.
+> The only supported routing pattern is PageRegistry.register() + DynamicRouter.
 > See references/frontend-route-wiring-app-tsx.md for the current pattern.
 
 ---
@@ -79,6 +79,274 @@ export function $MODULE_PASCALPage() {
 
 ---
 
+## TEMPLATE: DETAIL PAGE
+
+```tsx
+// pages/$APPLICATION/$MODULE/$MODULE_PASCALDetailPage.tsx
+
+import { useState, useEffect, useCallback } from 'react';
+import { useParams, useNavigate } from 'react-router-dom';
+import { useTranslation } from 'react-i18next';
+import { ArrowLeft, Pencil, Trash2, Loader2 } from 'lucide-react';
+import { Breadcrumb } from '@/components/ui/Breadcrumb';
+import { $moduleApi, type $ENTITY_PASCALDto } from '@/services/api/$moduleApi';
+
+export function $MODULE_PASCALDetailPage() {
+  // ⚠️ CRITICAL: DynamicRouter generates /:id — use destructuring rename
+  const { id: $entityId } = useParams<{ id: string }>();
+  const navigate = useNavigate();
+  const { t } = useTranslation(['$module', 'common']);
+
+  const [$entity, set$ENTITY_PASCAL] = useState<$ENTITY_PASCALDto | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const loadData = useCallback(async () => {
+    if (!$entityId) return;
+    try {
+      setLoading(true);
+      setError(null);
+      const data = await $moduleApi.getById($entityId);
+      set$ENTITY_PASCAL(data);
+    } catch (err) {
+      setError(t('common:errors.loadFailed'));
+      console.error('Failed to load $entity:', err);
+    } finally {
+      setLoading(false);
+    }
+  }, [$entityId, t]);
+
+  useEffect(() => {
+    loadData();
+  }, [loadData]);
+
+  const handleDelete = async () => {
+    if (!$entityId || !confirm(t('common:confirmDelete'))) return;
+    try {
+      await $moduleApi.delete($entityId);
+      navigate('..');
+    } catch (err) {
+      console.error('Failed to delete:', err);
+    }
+  };
+
+  if (loading) {
+    return (
+      <div className="flex items-center justify-center py-12">
+        <Loader2 className="w-8 h-8 animate-spin text-[var(--color-accent-500)]" />
+      </div>
+    );
+  }
+
+  if (error || !$entity) {
+    return (
+      <div className="p-6">
+        <p className="text-[var(--error-text)]">{error || t('common:errors.notFound')}</p>
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-6">
+      <Breadcrumb
+        items={[
+          { label: t('$module:title'), href: '/$APPLICATION_KEBAB/$MODULE_KEBAB' },
+          { label: $entity.name },
+        ]}
+      />
+
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-3">
+          <button onClick={() => navigate('..')} className="p-2 hover:bg-[var(--bg-hover)]" style={{ borderRadius: 'var(--radius-button)' }}>
+            <ArrowLeft className="w-5 h-5" />
+          </button>
+          <h1 className="text-2xl font-bold text-[var(--text-primary)]">{$entity.name}</h1>
+        </div>
+        <div className="flex items-center gap-2">
+          <button
+            onClick={() => navigate('edit')}
+            className="flex items-center gap-2 px-4 py-2 bg-[var(--color-accent-500)] hover:bg-[var(--color-accent-600)] text-white font-medium transition-colors"
+            style={{ borderRadius: 'var(--radius-button)' }}
+          >
+            <Pencil className="w-4 h-4" />
+            {t('common:actions.edit')}
+          </button>
+          <button
+            onClick={handleDelete}
+            className="flex items-center gap-2 px-4 py-2 bg-[var(--error-bg)] hover:bg-[var(--error-border)] text-[var(--error-text)] font-medium transition-colors"
+            style={{ borderRadius: 'var(--radius-button)' }}
+          >
+            <Trash2 className="w-4 h-4" />
+            {t('common:actions.delete')}
+          </button>
+        </div>
+      </div>
+
+      {/* Detail content — adapt to your entity */}
+      <div className="bg-[var(--bg-card)] border border-[var(--item-color-border)] p-6" style={{ borderRadius: 'var(--radius-card)' }}>
+        <dl className="grid grid-cols-1 md:grid-cols-2 gap-4">
+          <div>
+            <dt className="text-sm font-medium text-[var(--text-secondary)]">{t('$module:columns.name')}</dt>
+            <dd className="mt-1 text-[var(--text-primary)]">{$entity.name}</dd>
+          </div>
+          <div>
+            <dt className="text-sm font-medium text-[var(--text-secondary)]">{t('$module:columns.description')}</dt>
+            <dd className="mt-1 text-[var(--text-primary)]">{$entity.description || '-'}</dd>
+          </div>
+        </dl>
+      </div>
+    </div>
+  );
+}
+```
+
+---
+
+## TEMPLATE: EDIT PAGE
+
+```tsx
+// pages/$APPLICATION/$MODULE/$MODULE_PASCALEditPage.tsx
+
+import { useState, useEffect, useCallback } from 'react';
+import { useParams, useNavigate } from 'react-router-dom';
+import { useTranslation } from 'react-i18next';
+import { ArrowLeft, Save, Loader2 } from 'lucide-react';
+import { Breadcrumb } from '@/components/ui/Breadcrumb';
+import { $moduleApi, type $ENTITY_PASCALDto, type Update$ENTITY_PASCALRequest } from '@/services/api/$moduleApi';
+
+export function $MODULE_PASCALEditPage() {
+  // ⚠️ CRITICAL: DynamicRouter generates /:id/edit — use destructuring rename
+  const { id: $entityId } = useParams<{ id: string }>();
+  const navigate = useNavigate();
+  const { t } = useTranslation(['$module', 'common']);
+
+  const [data, setData] = useState<$ENTITY_PASCALDto | null>(null);
+  const [form, setForm] = useState<Update$ENTITY_PASCALRequest>({ name: '', description: '' });
+  const [loading, setLoading] = useState(true);
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const loadData = useCallback(async () => {
+    if (!$entityId) return;
+    try {
+      setLoading(true);
+      const result = await $moduleApi.getById($entityId);
+      setData(result);
+      setForm({ name: result.name, description: result.description || '' });
+    } catch (err) {
+      setError(t('common:errors.loadFailed'));
+      console.error('Failed to load $entity:', err);
+    } finally {
+      setLoading(false);
+    }
+  }, [$entityId, t]);
+
+  useEffect(() => {
+    loadData();
+  }, [loadData]);
+
+  const handleSave = async () => {
+    if (!$entityId) return;
+    try {
+      setSaving(true);
+      setError(null);
+      await $moduleApi.update($entityId, form);
+      navigate('..');
+    } catch (err) {
+      setError(t('common:errors.saveFailed'));
+      console.error('Failed to save:', err);
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  if (loading) {
+    return (
+      <div className="flex items-center justify-center py-12">
+        <Loader2 className="w-8 h-8 animate-spin text-[var(--color-accent-500)]" />
+      </div>
+    );
+  }
+
+  return (
+    <div className="space-y-6">
+      <Breadcrumb
+        items={[
+          { label: t('$module:title'), href: '/$APPLICATION_KEBAB/$MODULE_KEBAB' },
+          { label: data?.name || '...', href: '..' },
+          { label: t('common:actions.edit') },
+        ]}
+      />
+
+      <div className="flex items-center gap-3">
+        <button onClick={() => navigate('..')} className="p-2 hover:bg-[var(--bg-hover)]" style={{ borderRadius: 'var(--radius-button)' }}>
+          <ArrowLeft className="w-5 h-5" />
+        </button>
+        <h1 className="text-2xl font-bold text-[var(--text-primary)]">
+          {t('common:actions.edit')} — {data?.name}
+        </h1>
+      </div>
+
+      {error && (
+        <div className="p-4 bg-[var(--error-bg)] border border-[var(--error-border)]" style={{ borderRadius: 'var(--radius-card)' }}>
+          <span className="text-[var(--error-text)]">{error}</span>
+        </div>
+      )}
+
+      <div className="bg-[var(--bg-card)] border border-[var(--item-color-border)] p-6" style={{ borderRadius: 'var(--radius-card)' }}>
+        <div className="space-y-4 max-w-lg">
+          <div>
+            <label className="block text-sm font-medium text-[var(--text-secondary)] mb-1">
+              {t('$module:columns.name')}
+            </label>
+            <input
+              type="text"
+              value={form.name}
+              onChange={(e) => setForm(prev => ({ ...prev, name: e.target.value }))}
+              className="w-full px-3 py-2 bg-[var(--bg-primary)] border border-[var(--border-color)] text-sm focus:outline-none focus:border-[var(--color-accent-500)]"
+              style={{ borderRadius: 'var(--radius-input)' }}
+            />
+          </div>
+          <div>
+            <label className="block text-sm font-medium text-[var(--text-secondary)] mb-1">
+              {t('$module:columns.description')}
+            </label>
+            <textarea
+              value={form.description || ''}
+              onChange={(e) => setForm(prev => ({ ...prev, description: e.target.value }))}
+              rows={3}
+              className="w-full px-3 py-2 bg-[var(--bg-primary)] border border-[var(--border-color)] text-sm focus:outline-none focus:border-[var(--color-accent-500)]"
+              style={{ borderRadius: 'var(--radius-input)' }}
+            />
+          </div>
+        </div>
+
+        <div className="flex justify-end gap-3 mt-6 pt-4 border-t border-[var(--border-color)]">
+          <button
+            onClick={() => navigate('..')}
+            className="px-4 py-2 bg-[var(--bg-secondary)] hover:bg-[var(--bg-tertiary)] text-[var(--text-primary)] font-medium transition-colors"
+            style={{ borderRadius: 'var(--radius-button)' }}
+          >
+            {t('common:actions.cancel')}
+          </button>
+          <button
+            onClick={handleSave}
+            disabled={saving}
+            className="flex items-center gap-2 px-4 py-2 bg-[var(--color-accent-500)] hover:bg-[var(--color-accent-600)] text-white font-medium transition-colors disabled:opacity-50"
+            style={{ borderRadius: 'var(--radius-button)' }}
+          >
+            {saving ? <Loader2 className="w-4 h-4 animate-spin" /> : <Save className="w-4 h-4" />}
+            {t('common:actions.save')}
+          </button>
+        </div>
+      </div>
+    </div>
+  );
+}
+```
+
+---
+
 ## TEMPLATE: LIST VIEW (Reusable component)
 
 ```tsx
@@ -507,117 +775,108 @@ export const $moduleApi = {
 
 ---
 
-## TEMPLATE: ROUTES (App.tsx)
-
-### Detect App.tsx Routing Pattern FIRST
+## TEMPLATE: ROUTES (PageRegistry + DynamicRouter)
 
-Before adding routes, **read App.tsx** and detect which pattern is used:
+### Default Pattern (v3.7+): PageRegistry + DynamicRouter
 
-| Pattern | How to detect | Action |
-|---------|---------------|--------|
-| **Pattern A** (mergeRoutes) | `applicationRoutes: ApplicationRouteExtensions` present | Add to `applicationRoutes.{application}[]` array |
-| **Pattern B** (JSX Routes) | `<Route path="/{application}" element={<{Layout} />}>` present | Insert `<Route>` children inside Layout wrapper |
+> **This is the ONLY supported pattern** since v3.7.
+> Pages are registered in `componentRegistry.generated.ts` via `PageRegistry.register()`.
+> DynamicRouter resolves routes automatically from the navigation API + PageRegistry.
+> **No App.tsx wiring needed.** No manual route duplication for tenant prefixes.
 
-### Pattern A: mergeRoutes (applicationRoutes array)
+**Steps:**
 
-> **This is the DEFAULT pattern** generated by `smartstack init`.
-> Routes added to `applicationRoutes` are automatically injected into BOTH standard and tenant-prefixed route trees by `mergeRoutes()`. No manual duplication needed.
+1. Create your page component(s)
+2. Register in `componentRegistry.generated.ts` (or run `scaffold_routes outputFormat="componentRegistry"`)
+3. Ensure navigation seed data has matching `ComponentKey` values
+4. DynamicRouter does the rest
 
 ```tsx
-// Add to App.tsx — imports at top
-import { $MODULE_PASCALPage } from '@/pages/$APPLICATION/$MODULE/$MODULE_PASCALPage';
-import { $MODULE_PASCALDetailPage } from '@/pages/$APPLICATION/$MODULE/$MODULE_PASCALDetailPage';
-import { Create$MODULE_PASCALPage } from '@/pages/$APPLICATION/$MODULE/Create$MODULE_PASCALPage';
-
-// Add routes to applicationRoutes.{application}[] with RELATIVE paths (no leading /)
-const applicationRoutes: ApplicationRouteExtensions = {
-  '$APPLICATION_KEBAB': [
-    // ... existing routes ...
-    { path: '$MODULE_KEBAB', element: <$MODULE_PASCALPage /> },
-    { path: '$MODULE_KEBAB/create', element: <Create$MODULE_PASCALPage /> },
-    { path: '$MODULE_KEBAB/:id', element: <$MODULE_PASCALDetailPage /> },
-    { path: '$MODULE_KEBAB/:id/edit', element: <Create$MODULE_PASCALPage /> },
-  ],
-};
+// 1. Create page component
+// pages/$APPLICATION/$MODULE/$MODULE_PASCALPage.tsx
+export function $MODULE_PASCALPage() { /* ... */ }
+
+// 2. Register in componentRegistry.generated.ts
+import { PageRegistry } from '@/extensions/PageRegistry';
+
+PageRegistry.register(
+  '$APPLICATION_KEBAB.$MODULE_KEBAB',
+  lazy(() => import('@/pages/$APPLICATION/$MODULE/$MODULE_PASCALPage')
+    .then(m => ({ default: m.$MODULE_PASCALPage })))
+);
+
+// For CRUD sub-pages (detail, create):
+PageRegistry.register(
+  '$APPLICATION_KEBAB.$MODULE_KEBAB.detail',
+  lazy(() => import('@/pages/$APPLICATION/$MODULE/$MODULE_PASCALDetailPage')
+    .then(m => ({ default: m.$MODULE_PASCALDetailPage })))
+);
+
+PageRegistry.register(
+  '$APPLICATION_KEBAB.$MODULE_KEBAB.create',
+  lazy(() => import('@/pages/$APPLICATION/$MODULE/Create$MODULE_PASCALPage')
+    .then(m => ({ default: m.Create$MODULE_PASCALPage })))
+);
 ```
 
-**mergeRoutes auto-generates redirects** for intermediate paths (e.g., `$APPLICATION` → `$APPLICATION/$DEFAULT_MODULE_KEBAB`) so you don't need to add index redirects manually.
+```sql
+-- 3. Navigation seed data (ComponentKey must match PageRegistry key)
+INSERT INTO core.nav_Sections (...)
+VALUES (..., ComponentKey = '$APPLICATION_KEBAB.$MODULE_KEBAB', ...);
+```
 
-**Application-to-Layout mapping (automatic via mergeRoutes):**
+### ⚠️ IMPLICIT ROUTE PARAM CONVENTION
 
-| Application key | Injected into Layout | Standard path | Tenant path |
-|-----------------|---------------------|---------------|-------------|
-| `administration` | `AppLayout` | `/administration/...` | `/t/:slug/administration/...` |
-| `{application}` | `AppLayout` | `/{application}/...` | `/t/:slug/{application}/...` |
-| `myspace` | `AppLayout` | `/myspace/...` | `/t/:slug/myspace/...` |
+DynamicRouter generates implicit sub-routes for `.detail`, `.create`, and `.edit` page keys:
 
-### Pattern B: JSX Routes (inside Layout wrapper)
+| Suffix | URL pattern | Route param |
+|--------|-------------|-------------|
+| `.detail` | `/:id` | `id` |
+| `.create` | `/create` | — |
+| `.edit` | `/:id/edit` | `id` |
 
-> **Legacy pattern** — only used if App.tsx was manually restructured with JSX `<Route>` elements.
+**The route param is ALWAYS `id`** — never `ticketId`, `userId`, or any entity-specific name.
 
-The unified `AppLayout` provides the application shell: **header with AvatarMenu**, sidebar, navigation. It renders child pages via React Router's `<Outlet />`.
+In detail/edit pages, use destructuring rename to keep a readable local variable:
 
-**If routes are placed OUTSIDE the layout wrapper, the shell (header, sidebar, AvatarMenu) will NOT render. The page appears "naked" without any navigation.**
+```tsx
+// ✅ CORRECT — matches DynamicRouter's /:id pattern
+const { id: $entityId } = useParams<{ id: string }>();
 
-**Step-by-step insertion:**
+// ❌ WRONG — will be undefined because the route param is :id, not :$entityId
+const { $entityId } = useParams<{ $entityId: string }>();
+```
 
-1. Open `App.tsx`
-2. Find the existing layout route for the target application:
-   - `administration` → `<Route path="/administration" element={<AppLayout />}>`
-   - `{application}` → `<Route path="/{application}" element={<AppLayout />}>`
-   - `myspace` → `<Route path="/myspace" element={<AppLayout />}>`
-3. Add the new routes **INSIDE** that `<Route>` block
-4. If a tenant-prefixed block exists (`/t/:slug/...`), add the routes there too
+### How DynamicRouter resolves routes
 
-```tsx
-// Add to App.tsx
-
-import { $MODULE_PASCALPage } from '@/pages/$APPLICATION/$MODULE/$MODULE_PASCALPage';
-import { $MODULE_PASCALDetailPage } from '@/pages/$APPLICATION/$MODULE/$MODULE_PASCALDetailPage';
-import { Create$MODULE_PASCALPage } from '@/pages/$APPLICATION/$MODULE/Create$MODULE_PASCALPage';
-
-// Find the EXISTING layout route and add routes INSIDE it:
-<Route path="/$APPLICATION" element={<$APPLICATION_Layout />}>
-  {/* ... existing routes stay here ... */}
-
-  {/* NEW: $MODULE routes - added as children of the layout */}
-  <Route path="$MODULE_KEBAB">
-    <Route index element={<Navigate to="." replace />} />
-    <Route index element={<$MODULE_PASCALPage />} />
-    <Route path="create" element={<Create$MODULE_PASCALPage />} />
-    <Route path=":id" element={<$MODULE_PASCALDetailPage />} />
-    <Route path=":id/edit" element={<Create$MODULE_PASCALPage />} />
-  </Route>
-</Route>
-```
+1. Fetches menu from `GET /api/navigation/menu`
+2. For each Application → Module → Section → Resource, builds `<Route>` elements
+3. Looks up each item's `ComponentKey` in `PageRegistry` to get the React component
+4. Wraps routes in `<ProtectedRoute>` (API-driven permission check via `isOpen` flag)
+5. Generates both standard (`/$APPLICATION/$MODULE`) and tenant-prefixed (`/t/:slug/$APPLICATION/$MODULE`) routes automatically
 
-### ⚠️ CRITICAL RULES (both patterns)
+### ⚠️ CRITICAL RULES
 
-**FORBIDDEN — Adding to clientRoutes[] with absolute paths:**
+**FORBIDDEN — Flat routes outside DynamicRouter:**
 ```tsx
-// ❌ WRONG — bypasses layout entirely, shell will NOT render
-const clientRoutes: RouteConfig[] = [
-  { path: '/$APPLICATION_KEBAB/$MODULE_KEBAB', element: <$MODULE_PASCALPage /> },
-];
+// ❌ WRONG — bypasses layout, permission checks, and tenant handling
+<Route path="/$APPLICATION_KEBAB/$MODULE_KEBAB" element={<$MODULE_PASCALPage />} />
 ```
 
-`clientRoutes` is ONLY for routes **outside** SmartStack locked applications (e.g., `/about`, `/pricing`).
-
-**FORBIDDEN — Flat routes outside layout:**
+**FORBIDDEN — Registering pages without navigation seed data:**
 ```tsx
-// ❌ WRONG (Pattern B only) — flat route bypasses layout
-<Route path="/$APPLICATION_KEBAB/$MODULE_KEBAB" element={<$MODULE_PASCALPage />} />
+// ❌ WRONG — PageRegistry.register() alone does nothing without a matching ComponentKey in the DB
+PageRegistry.register('my-app.my-module', MyPage);
+// Must also have INSERT INTO core.nav_Sections with ComponentKey = 'my-app.my-module'
 ```
 
-### Why nested/context routes?
+---
+
+### Legacy Patterns (DEPRECATED — removed in v3.7)
 
-| Aspect | clientRoutes (wrong) | applicationRoutes / nested (correct) |
-|--------|---------------------|--------------------------------------|
-| Shell rendered | No (bypasses layout) | Yes (Outlet pattern) |
-| AvatarMenu visible | No | Yes |
-| Tenant prefix | Manual duplication | Automatic (mergeRoutes) |
-| Auto-redirects | None | Generated for intermediate paths |
-| Permission check | Bypassed (no RouteGuard) | Enforced by RouteGuard |
+> **Pattern A (mergeRoutes)** and **Pattern B (JSX Routes)** were removed in v3.7.
+> `smartstackRoutes.tsx`, `RouteGuard.tsx`, and `mergeRoutes()` no longer exist.
+> If you encounter a pre-v3.7 project, upgrade to PageRegistry + DynamicRouter.
 
 ---
 
@@ -649,11 +908,13 @@ These patterns are **strictly prohibited** in generated frontend code:
 | Check | Status |
 |-------|--------|
 | ☐ Main page created (`$MODULE_PASCALPage.tsx`) | |
+| ☐ Detail page created (`$MODULE_PASCALDetailPage.tsx`) with `useParams<{ id: string }>` | |
+| ☐ Edit page created (`$MODULE_PASCALEditPage.tsx`) with `useParams<{ id: string }>` | |
 | ☐ ListView component created (`$MODULE_PASCALListView.tsx`) | |
 | ☐ Preferences hook created (`use$MODULE_PASCALPreferences.ts`) | |
 | ☐ API service created (uses `apiClient`, NOT raw axios) | |
-| ☐ Routes added inside Layout wrapper in App.tsx | |
-| ☐ Route path follows `/{application_kebab}/{module_kebab}` (kebab-case) | |
+| ☐ PageRegistry keys registered (`.detail`, `.create`, `.edit`) in `componentRegistry.generated.ts` | |
+| ☐ Route param uses `{ id: entityId }` destructuring (NOT `{ entityId }`) | |
 
 ### Theme Compliance
 | Check | Status |

package/templates/skills/application/templates-seed.md

@@ -805,7 +805,7 @@ public class {AppPascalName}SeedDataProvider : IClientSeedDataProvider
         else
         {
             app = NavigationApplication.Create(
-                "{app_code}", "{app_label_en}",
+                ApplicationZone.Business, "{app_code}", "{app_label_en}",
                 "{app_desc_en}", "{app_icon}", IconType.Lucide,
                 "/{app_code}", {display_order});
             context.NavigationApplications.Add(app);
@@ -822,17 +822,23 @@ public class {AppPascalName}SeedDataProvider : IClientSeedDataProvider
 
         // Module translations — IDEMPOTENT (unique index IX_nav_Translations_EntityType_EntityId_LanguageCode)
         // CRITICAL: Always check before inserting to avoid duplicate key errors on re-runs
+        // CRITICAL: Use modEntity.Id (actual DB ID), NOT seed-time GUID from SeedData class.
         // if (!await context.NavigationTranslations.AnyAsync(
-        //     t => t.EntityId == {Module}NavigationSeedData.{Module}ModuleId && t.EntityType == NavigationEntityType.Module, ct))
-        // { foreach (var t in {Module}NavigationSeedData.GetTranslationEntries()) { ... } }
+        //     t => t.EntityId == mod1Entity.Id && t.EntityType == NavigationEntityType.Module, ct))
+        // { foreach (var t in {Module}NavigationSeedData.GetTranslationEntries())
+        //   { context.NavigationTranslations.Add(
+        //       NavigationTranslation.Create(t.EntityType, mod1Entity.Id, t.LanguageCode, t.Label, t.Description)); } }
 
         // Sections (idempotent per-section — check each before inserting)
         // var secExists = await context.NavigationSections.AnyAsync(s => s.Code == secEntry.Code && s.ModuleId == ..., ct);
         // Use NavigationSection.Create(moduleId, code, label, description, icon, iconType, route, displayOrder)
 
         // Section translations — IDEMPOTENT (same guard pattern as module translations)
+        // CRITICAL: Resolve actual section from DB (secEntry.Id is seed-time GUID ≠ DB ID):
+        // var actualSection = await context.NavigationSections
+        //     .FirstAsync(s => s.Code == secEntry.Code && s.ModuleId == modEntity.Id, ct);
         // if (!await context.NavigationTranslations.AnyAsync(
-        //     t => t.EntityId == secEntry.Id && t.EntityType == NavigationEntityType.Section, ct))
+        //     t => t.EntityId == actualSection.Id && t.EntityType == NavigationEntityType.Section, ct))
 
         // Resources (idempotent per-resource — check each before inserting)
         // var resExists = await context.NavigationResources.AnyAsync(r => r.Code == resEntry.Code && r.SectionId == ..., ct);
@@ -841,20 +847,26 @@ public class {AppPascalName}SeedDataProvider : IClientSeedDataProvider
 
     public async Task SeedRolesAsync(ICoreDbContext context, CancellationToken ct)
     {
-        // Check idempotence
+        // Resolve application from DB by Code — NOT seed-time GUID
+        var app = await context.NavigationApplications
+            .FirstAsync(a => a.Code == "{app_code}", ct);
+
+        // Check idempotence — scoped by actual DB ApplicationId
         var exists = await context.Roles
-            .AnyAsync(r => r.ApplicationId == ApplicationRolesSeedData.ApplicationId, ct);
+            .AnyAsync(r => r.ApplicationId == app.Id, ct);
         if (exists) return;
 
         // Create application-scoped roles (Admin, Manager, Contributor, Viewer)
         foreach (var entry in ApplicationRolesSeedData.GetRoleEntries())
         {
             var role = Role.Create(
-                entry.Code,
-                entry.Name,
-                entry.Description,
-                entry.ApplicationId,
-                entry.IsSystem);
+                name: entry.Name,
+                shortName: entry.Code,
+                category: RoleCategory.Application,
+                description: entry.Description,
+                isSystem: entry.IsSystem,
+                applicationId: app.Id,
+                code: entry.Code);
             context.Roles.Add(role);
         }
         await ((DbContext)context).SaveChangesAsync(ct);