@postxl/generators 1.18.0 → 1.19.0

package/dist/frontend-admin/generators/comment-sidebar.generator.js

@@ -184,6 +184,14 @@ export function ${context.admin.components.commentSidebar.name}({ model, filtere
   }, [currentUserId, createComment, model, commentTarget])
 
   const selectedLabel = selectedEntityId ? labelMap?.[selectedEntityId] ?? selectedEntityId : undefined
+  let commentListOnCreate: ((text: string) => void) | undefined
+  if (currentUserId) {
+    if (singleCommentThread && groups.length === 1) {
+      commentListOnCreate = (text: string) => handleCreate(text, groups[0].groupId)
+    } else {
+      commentListOnCreate = handleCreate
+    }
+  }
 
   if (!commentsLoaded) {
     return (
@@ -237,7 +245,7 @@ export function ${context.admin.components.commentSidebar.name}({ model, filtere
             comments={singleCommentThread && groups.length === 1 ? groups[0].comments : groups}
             onResolve={handleResolve}
             onReply={currentUserId ? handleReply : undefined}
-            onCreate={singleCommentThread && groups.length === 1 ? (currentUserId ? (text: string) => handleCreate(text, groups[0].groupId) : undefined) : (currentUserId ? handleCreate : undefined)}
+            onCreate={commentListOnCreate}
           />
         )}
     </div>

package/dist/frontend-admin/generators/comment-sidebar.generator.js.map

@@ -1 +1 @@
-{"version":3,"file":"comment-sidebar.generator.js","sourceRoot":"","sources":["../../../src/frontend-admin/generators/comment-sidebar.generator.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,wDA+MC;AAxND,6DAA8C;AAI9C;;;;GAIG;AACH,SAAgB,sBAAsB,CAAC,EAAE,OAAO,EAA8B;IAC5E,MAAM,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,SAAgB,CAAE,CAAA;IAC1D,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,MAAa,CAAE,CAAA;IAEpD,MAAM,OAAO,GAAG,SAAS,CAAC,eAAe;QACvC,EAAE;SACD,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,cAAe,CAAC,QAAQ,CAAC;SACvD,SAAS,CAAC;QACT,IAAI,EAAE,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC;QACtC,KAAK,EAAE;YACL,SAAS,CAAC,cAAc,CAAC,UAAU,CAAC;YACpC,SAAS,CAAC,cAAc,CAAC,SAAS,CAAC;YACnC,SAAS,CAAC,cAAc,CAAC,aAAa,CAAC;YACvC,SAAS,CAAC,cAAc,CAAC,WAAW,CAAC;SACtC;KACF,CAAC;SACD,GAAG,CAAC,YAAY,CAAC,SAAS,CAAC;SAC3B,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC;SACxB,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;SAC9B,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IAE9B,MAAM,cAAc,GAAG,SAAS,CAAC,UAAU,CAAC,IAAI,CAAA;IAEhD,OAAO;EACP,OAAO,CAAC,QAAQ,EAAE;;;;;;;;;;;;;;kBAcF,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,cAAe,CAAC,IAAI;;;;;;MAMzD,YAAY,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI;MACxC,YAAY,CAAC,SAAS,CAAC,MAAO,CAAC,IAAI;MACnC,YAAY,CAAC,SAAS,CAAC,WAAY,CAAC,IAAI;MACxC,YAAY,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI;QAClC,YAAY,CAAC,SAAS,CAAC,IAAI;;;;;;;;;YASvB,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,iBAAiB,SAAS,CAAC,SAAS,CAAC,IAAI;;;;;;;;;;0BAUvD,cAAc;;;;yDAIiB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAiCtB,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI;;;;;;;;iCAQ1C,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI;;;;sCAIlB,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI;;;;;;;;iCAQ/B,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI;;;;;;;;;;;;iCAYvB,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsEvD,CAAA;AACD,CAAC"}
+{"version":3,"file":"comment-sidebar.generator.js","sourceRoot":"","sources":["../../../src/frontend-admin/generators/comment-sidebar.generator.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,wDAuNC;AAhOD,6DAA8C;AAI9C;;;;GAIG;AACH,SAAgB,sBAAsB,CAAC,EAAE,OAAO,EAA8B;IAC5E,MAAM,YAAY,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,SAAgB,CAAE,CAAA;IAC1D,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,MAAa,CAAE,CAAA;IAEpD,MAAM,OAAO,GAAG,SAAS,CAAC,eAAe;QACvC,EAAE;SACD,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,cAAe,CAAC,QAAQ,CAAC;SACvD,SAAS,CAAC;QACT,IAAI,EAAE,SAAS,CAAC,aAAa,CAAC,OAAO,CAAC;QACtC,KAAK,EAAE;YACL,SAAS,CAAC,cAAc,CAAC,UAAU,CAAC;YACpC,SAAS,CAAC,cAAc,CAAC,SAAS,CAAC;YACnC,SAAS,CAAC,cAAc,CAAC,aAAa,CAAC;YACvC,SAAS,CAAC,cAAc,CAAC,WAAW,CAAC;SACtC;KACF,CAAC;SACD,GAAG,CAAC,YAAY,CAAC,SAAS,CAAC;SAC3B,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC;SACxB,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC;SAC9B,OAAO,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA;IAE9B,MAAM,cAAc,GAAG,SAAS,CAAC,UAAU,CAAC,IAAI,CAAA;IAEhD,OAAO;EACP,OAAO,CAAC,QAAQ,EAAE;;;;;;;;;;;;;;kBAcF,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,cAAe,CAAC,IAAI;;;;;;MAMzD,YAAY,CAAC,SAAS,CAAC,YAAY,CAAC,IAAI;MACxC,YAAY,CAAC,SAAS,CAAC,MAAO,CAAC,IAAI;MACnC,YAAY,CAAC,SAAS,CAAC,WAAY,CAAC,IAAI;MACxC,YAAY,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI;QAClC,YAAY,CAAC,SAAS,CAAC,IAAI;;;;;;;;;YASvB,SAAS,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,iBAAiB,SAAS,CAAC,SAAS,CAAC,IAAI;;;;;;;;;;0BAUvD,cAAc;;;;yDAIiB,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iDAiCtB,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI;;;;;;;;iCAQ1C,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI;;;;sCAIlB,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI;;;;;;;;iCAQ/B,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI;;;;;;;;;;;;iCAYvB,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8EvD,CAAA;AACD,CAAC"}

package/dist/frontend-admin/generators/model-admin-page.generator.js

@@ -39,6 +39,8 @@ const Generator = __importStar(require("@postxl/generator"));
  * Generator function that generates the Admin page for a model
  */
 function generateModelAdminPage({ model, context, }) {
+    const adminUiPolicy = resolveAdminUiPolicy(model, context);
+    const writePolicy = resolveWritePolicy(model, context);
     const imports = Generator.ImportGenerator
         //
         .from(model.admin.page.pageComponent.location)
@@ -100,115 +102,45 @@ function generateModelAdminPage({ model, context, }) {
         ],
     });
     const showComments = model.name !== 'Comment' && !!context.admin.components.commentSidebar;
-    if (showComments) {
-        imports.add(context.admin.components.commentSidebar);
-        imports.addImport({
-            from: Generator.toPackageName('lucide-react'),
-            items: [
-                Generator.toFunctionName('ListTree'),
-                Generator.toFunctionName('MessageSquareText'),
-                Generator.toFunctionName('ScrollText'),
-                Generator.toFunctionName('Sparkles'),
-            ],
-        });
-    }
-    else {
-        imports.addImport({
-            from: Generator.toPackageName('lucide-react'),
-            items: [
-                Generator.toFunctionName('ListTree'),
-                Generator.toFunctionName('ScrollText'),
-                Generator.toFunctionName('Sparkles'),
-            ],
-        });
-    }
-    const relatedModels = [];
-    for (const relatedModelName of model.relatedModelNames) {
-        const relatedModel = context.models.get(relatedModelName);
-        imports.add(relatedModel.itemsHook);
-        relatedModels.push({
-            model: relatedModel,
-            mapName: relatedModel.internalPluralName,
-            mapDefinition: `const {${relatedModel.itemsHook.map.name}: ${relatedModel.internalPluralName}} = ${relatedModel.itemsHook.name}()`,
-        });
-    }
-    let createModalHook = '';
-    let createModalIntentHook = '';
-    let createModal = '';
-    if (!model.isReadonly) {
-        imports
-            //
-            .addType(model.types.id)
-            .addImport({ from: Generator.toPackageName('react'), items: [Generator.toFunctionName('useRef')] })
-            .addImport({ from: Generator.toPackageName('sonner'), items: [Generator.toFunctionName('toast')] })
-            .addImport({ from: model.forms.createModal.location, items: [model.forms.createModal.name] });
-        // In case the model does not provide any explicit label field, we generally use the id field as fallback.
-        // However, in case of creating a new item, we do not have an Id yet and hence cannot show it in success and error messages.
-        const hasLabelField = model.labelField.name !== model.idField.name;
-        const variableName = hasLabelField ? `created${model.name}` : '_';
-        const label = hasLabelField ? ` "\${${variableName}.${model.labelField.name}}"` : '';
-        createModalHook = ` const [isCreateModalOpen, setIsCreateModalOpen] = useState(false)`;
-        createModalIntentHook = `
-  useEffect(() => {
-    if (typeof globalThis === 'undefined') {
-      return
-    }
-
-    const storageKey = 'pxl:create-intent-model'
-    const targetModel = '${model.name}'
-    const openFromIntent = (intentModel: unknown) => {
-      if (intentModel === targetModel) {
-        setIsCreateModalOpen(true)
-        globalThis.sessionStorage.removeItem(storageKey)
-      }
-    }
-
-    openFromIntent(globalThis.sessionStorage.getItem(storageKey))
-
-    const onIntent = (event: Event) => {
-      const detail = (event as CustomEvent<{ model?: string }>).detail
-      openFromIntent(detail?.model)
-    }
-
-    globalThis.addEventListener('pxl:create-intent', onIntent)
-    return () => {
-      globalThis.removeEventListener('pxl:create-intent', onIntent)
-    }
-  }, [])`;
-        createModal = `
-    <${model.forms.createModal.name}
-        open={isCreateModalOpen}
-        onClose={() => setIsCreateModalOpen(false)}
-        onSuccess={(${variableName}) => {
-          toast.success(\`${model.userFriendlyName}${label} created successfully!\`)
-          setIsCreateModalOpen(false)
-        }}
-        onError={(${variableName}, error) => {
-          toast.error(\`Error creating ${model.userFriendlyName}${label}: \${String(error)}\`)
-        }}
-      />`;
-    }
+    configureSidebarImports({ imports, context, showComments });
+    const relatedModels = collectRelatedModels({ model, context, imports });
+    const createModalContent = resolveCreateModalContent(model, imports);
+    const canAccessAdminExpression = toRoleExpression(adminUiPolicy, 'userRoles');
+    const canWriteModelExpression = toRoleExpression(writePolicy, 'userRoles');
+    const commentCountState = buildCommentCountState(showComments);
+    const modelHookMutationFields = buildModelHookMutationFields(model);
+    const commentSidebarLogic = buildCommentSidebarLogic({ showComments, model });
+    const commentSelectedEntityId = buildCommentSelectedEntityId(showComments);
+    const cellUpdateHandler = buildCellUpdateHandler(model);
+    const removeRowsHandler = buildRemoveRowsHandler(model);
+    const commentSidebarTab = buildCommentSidebarTab({ showComments, model });
+    const relatedTableProps = buildRelatedTableProps(relatedModels);
+    const addRowProp = buildAddRowProp(model);
+    const cellUpdateProp = buildCellUpdateProp(model);
+    const removeRowsProp = buildRemoveRowsProp(model);
     return `
-import { SidebarInset, SidebarTab, useDebouncedCallback } from '@postxl/ui-components'
+import { SidebarTab, useDebouncedCallback } from '@postxl/ui-components'
 import { APP_CONFIG } from '@lib/config'
 import { useAuth } from '@context-providers/auth-context-provider'
+import { hasAnyRole } from '@lib/authorization'
 ${imports.generate()}
 
 export default function ${model.admin.page.pageComponent.name}() {
   const navigate = useNavigate()
   const { viewerData } = useAuth()
   const currentUserId = viewerData?.user?.id
-  const isAdmin = viewerData?.userRoles?.includes('admin') ?? false
-  ${showComments ? 'const [commentCount, setCommentCount] = useState(0)' : ''}
+  const userRoles = viewerData?.userRoles ?? []
+  const canAccessAdminPage = ${canAccessAdminExpression}
+  const canWriteModel = ${canWriteModelExpression}
+  ${commentCountState}
 
   const { selectedKey, focusedCell } = useSearch({
     from: '/_auth-routes${model.admin.page.route}',
     select: (search) => ({ selectedKey: search.selectedKey, focusedCell: search.focusedCell }),
   })
-
-  ${createModalHook}
-  ${createModalIntentHook}
-
+  
+  ${createModalContent.hook}
+  ${createModalContent.intentHook}
   // Track selected row IDs from checkbox selection
   const [selectedRowIds, setSelectedRowIds] = useState<string[]>([])
 
@@ -226,7 +158,7 @@ export default function ${model.admin.page.pageComponent.name}() {
     hasNextPage,
     fetchNextPage,
     total,
-    ${model.isReadonly ? '' : `${model.itemsHook.updateField.name}: updateFieldMutation, ${model.itemsHook.updateFieldMany.name}: updateFieldManyMutation, ${model.itemsHook.deleteMany.name}: deleteManyMutation,`}
+    ${modelHookMutationFields}
   } = ${model.itemsHook.name}({ filters, sort: sortState })
 
   // Queries for related models' maps used by the table (passed as separate props)
@@ -244,18 +176,7 @@ export default function ${model.admin.page.pageComponent.name}() {
     return focusedCell
   }, [focusedCell])
 
-  ${showComments
-        ? `// Comment sidebar: compute filtered entity IDs and label map from table data
-  const commentFilteredIds = useMemo(() =>
-    filteredDataList?.map(item => String(item.id)) ?? [],
-    [filteredDataList]
-  )
-  const commentLabelMap = useMemo(() =>
-    Object.fromEntries((filteredDataList ?? []).map(item => [String(item.id), String(item.${model.labelField.name})])),
-    [filteredDataList]
-  )
-  `
-        : ''}
+  ${commentSidebarLogic}
   // Callback when row selection changes (checkbox)
   const handleRowSelectionChange = useCallback((rowIds: string[]) => {
     setSelectedRowIds(rowIds)
@@ -298,7 +219,7 @@ export default function ${model.admin.page.pageComponent.name}() {
   // Callback when cell focus changes in the table — also sets selectedKey from the focused row
   const handleCellChange = useCallback((args: { rowIndex: number; columnId: string }) => {
     const row = filteredDataList?.[args.rowIndex]
-    const key = row?.${model.keyField.name} != null ? String(row.${model.keyField.name}) : undefined
+    const key = row?.${model.keyField.name} == null ? undefined : String(row.${model.keyField.name})
     void navigate({ to: '${model.admin.page.route}', search: { selectedKey: key, focusedCell: args.columnId || undefined } })
     // Clear checkbox selection when focusing a cell
     setSelectedRowIds([])
@@ -306,6 +227,18 @@ export default function ${model.admin.page.pageComponent.name}() {
     
   useEffect(() => {
     const prefix = 'admin-${model._conjugated.kebabCase}-filter'
+    const getFilterInputSchema = (valueType: string) => {
+      if (valueType === 'number') {
+        return numberFilterInputSchema
+      }
+      if (valueType === 'date') {
+        return dateFilterInputSchema
+      }
+      if (valueType === 'boolean') {
+        return booleanFilterInputSchema
+      }
+      return stringFilterInputSchema
+    }
 
     const filterActions = Object.entries(${model.types.filter.config.name}).map(([field, fieldConfig]) =>
       input({
@@ -313,14 +246,7 @@ export default function ${model.admin.page.pageComponent.name}() {
         visibility: 'visible',
         group: 'Filter records by...',
         label: toFilterActionLabel(field),
-        inputSchema:
-          fieldConfig.valueType === 'number'
-            ? numberFilterInputSchema
-            : fieldConfig.valueType === 'date'
-              ? dateFilterInputSchema
-              : fieldConfig.valueType === 'boolean'
-                ? booleanFilterInputSchema
-                : stringFilterInputSchema,
+        inputSchema: getFilterInputSchema(fieldConfig.valueType),
         run: async (query, inputValue) => {
           if (fieldConfig.valueType === 'number') {
             const parsed = numberFilterInputSchema.safeParse(inputValue)
@@ -414,48 +340,15 @@ export default function ${model.admin.page.pageComponent.name}() {
     setSearchInput,
   ])
 
-  ${model.isReadonly
-        ? ''
-        : `// Batch cell updates: collect updates within the same microtask and send as one updateFieldMany
-  const pendingUpdatesRef = useRef<Map<string, { field: string; value: unknown; ids: ${model.types.id.name}[] }> | null>(null)
-
-  const handleCellUpdate = useCallback((args: { rowIndex: number; columnId: string; value: unknown }) => {
-    const row = filteredDataList?.[args.rowIndex]
-    if (!row) return
-
-    // Initialize batch map and schedule flush on first call in this microtask
-    if (!pendingUpdatesRef.current) {
-      pendingUpdatesRef.current = new Map()
-      queueMicrotask(() => {
-        const pending = pendingUpdatesRef.current
-        pendingUpdatesRef.current = null
-        if (!pending) return
+  ${commentSelectedEntityId}
 
-        for (const entry of pending.values()) {
-          if (entry.ids.length === 1) {
-            void updateFieldMutation({ id: entry.ids[0], field: entry.field, value: entry.value } as Parameters<typeof updateFieldMutation>[0])
-          } else {
-            void updateFieldManyMutation({ ids: entry.ids, field: entry.field, value: entry.value } as Parameters<typeof updateFieldManyMutation>[0])
-          }
-        }
-      })
-    }
+  ${cellUpdateHandler}
 
-    // Group by field+value so identical field updates across rows get batched
-    const key = \`\${args.columnId}::\${JSON.stringify(args.value)}\`
-    const existing = pendingUpdatesRef.current.get(key)
-    if (existing) {
-      existing.ids.push(row.id)
-    } else {
-      pendingUpdatesRef.current.set(key, { field: args.columnId, value: args.value, ids: [row.id] })
-    }
-  }, [filteredDataList, updateFieldMutation, updateFieldManyMutation])
-
-  function handleRemoveRows(rows: ${model.types.id.name}[]) {
-    void deleteManyMutation(rows)
+  ${removeRowsHandler}
+  
+  if (!canAccessAdminPage) {
+    return null
   }
-  `}
-
 
   return (
     <>
@@ -467,24 +360,7 @@ export default function ${model.admin.page.pageComponent.name}() {
       >
         <AdminSidebarNavContent />
       </SidebarTab>
-      ${showComments
-        ? `<SidebarTab
-        side="right"
-        id="comment-content"
-        icon={MessageSquareText}
-        label="Comment"
-        order={0}
-        badge={{ label: String(commentCount) }}
-      >
-        <ModelCommentContent
-            model="${model.name}"
-            filteredIds={commentFilteredIds}
-            labelMap={commentLabelMap}
-            selectedEntityId={selectedEntityId ? String(selectedEntityId) : selectedRowIds.length === 1 ? selectedRowIds[0] : undefined}
-            onCommentCountChange={setCommentCount}
-          />
-      </SidebarTab>`
-        : ''}
+      ${commentSidebarTab}
       <SidebarTab
         side="right"
         id="audit-log-content"
@@ -514,7 +390,7 @@ export default function ${model.admin.page.pageComponent.name}() {
             <AiSidebarContent />
         </SidebarTab>
       )}
-      <SidebarInset className="p-4 overflow-hidden gap-4">
+      <div className="p-4 overflow-hidden gap-4">
         <h3 className="font-bold text-[1.75rem]">${model.userFriendlyName}</h3>
         <${model.table.component.name}
           data={filteredDataList ?? []}
@@ -534,11 +410,9 @@ export default function ${model.admin.page.pageComponent.name}() {
           onSearchInputChange={handleSearchInputChange}
           sort={sortState}
           onSortChange={setSortState}
-          ${model.isReadonly
-        ? ''
-        : `onCellUpdate={handleCellUpdate}
-            handleAddRow={() => setIsCreateModalOpen(true)}
-            handleRemoveRows={handleRemoveRows}`}
+          ${cellUpdateProp}
+          ${addRowProp}
+          ${removeRowsProp}
           onCellChange={handleCellChange}
           onRowSelectionChange={handleRowSelectionChange}
           selectedKey={selectedKey}
@@ -548,17 +422,306 @@ export default function ${model.admin.page.pageComponent.name}() {
           total={total}
           model="${model._conjugated.camelCase}"
           currentUserId={currentUserId}
-          isAdmin={isAdmin}
+          isAdmin={canWriteModel}
           onFiltersReplace={setFilters}
           onSortReplace={setSortState}
-          ${relatedModels.map((rm) => `${rm.model.table.propName}={${rm.mapName}}`).join('\n              ')}
+          ${relatedTableProps}
         />
-      </SidebarInset>
+      </div>
 
-      ${createModal}
+      ${createModalContent.modal}
     </>
   )
 }
 `;
 }
+function configureSidebarImports({ imports, context, showComments, }) {
+    if (showComments) {
+        imports.add(context.admin.components.commentSidebar);
+        imports.addImport({
+            from: Generator.toPackageName('lucide-react'),
+            items: [
+                Generator.toFunctionName('ListTree'),
+                Generator.toFunctionName('MessageSquareText'),
+                Generator.toFunctionName('ScrollText'),
+                Generator.toFunctionName('Sparkles'),
+            ],
+        });
+        return;
+    }
+    imports.addImport({
+        from: Generator.toPackageName('lucide-react'),
+        items: [
+            Generator.toFunctionName('ListTree'),
+            Generator.toFunctionName('ScrollText'),
+            Generator.toFunctionName('Sparkles'),
+        ],
+    });
+}
+function collectRelatedModels({ model, context, imports, }) {
+    const relatedModels = [];
+    for (const relatedModelName of model.relatedModelNames) {
+        const relatedModel = context.models.get(relatedModelName);
+        imports.add(relatedModel.itemsHook);
+        relatedModels.push({
+            model: relatedModel,
+            mapName: relatedModel.internalPluralName,
+            mapDefinition: `const {${relatedModel.itemsHook.map.name}: ${relatedModel.internalPluralName}} = ${relatedModel.itemsHook.name}()`,
+        });
+    }
+    return relatedModels;
+}
+function toRoleExpression(policy, userRolesVariableName) {
+    if (policy.allowAll) {
+        return 'true';
+    }
+    return `hasAnyRole(${userRolesVariableName}, ${JSON.stringify(policy.roles)})`;
+}
+function buildCommentCountState(showComments) {
+    if (!showComments) {
+        return '';
+    }
+    return 'const [commentCount, setCommentCount] = useState(0)';
+}
+function buildModelHookMutationFields(model) {
+    const fields = [];
+    if (model.itemsHook.updateField) {
+        fields.push(`${model.itemsHook.updateField.name}: updateFieldMutation,`);
+    }
+    if (model.itemsHook.updateFieldMany) {
+        fields.push(`${model.itemsHook.updateFieldMany.name}: updateFieldManyMutation,`);
+    }
+    if (model.itemsHook.deleteMany) {
+        fields.push(`${model.itemsHook.deleteMany.name}: deleteManyMutation,`);
+    }
+    return fields.join('\n    ');
+}
+function buildCommentSidebarLogic({ showComments, model, }) {
+    if (!showComments) {
+        return '';
+    }
+    return `// Comment sidebar: compute filtered entity IDs and label map from table data
+  const commentFilteredIds = useMemo(() =>
+    filteredDataList?.map(item => String(item.id)) ?? [],
+    [filteredDataList]
+  )
+  const commentLabelMap = useMemo(() =>
+    Object.fromEntries((filteredDataList ?? []).map(item => [String(item.id), String(item.${model.labelField.name})])),
+    [filteredDataList]
+  )`;
+}
+function buildCommentSelectedEntityId(showComments) {
+    if (!showComments) {
+        return '';
+    }
+    return `
+  let commentSelectedEntityId: string | undefined
+  if (selectedEntityId) {
+    commentSelectedEntityId = String(selectedEntityId)
+  } else if (selectedRowIds.length === 1) {
+    commentSelectedEntityId = selectedRowIds[0]
+  }`;
+}
+function buildCellUpdateHandler(model) {
+    if (!model.itemsHook.updateField) {
+        return '';
+    }
+    const flushMutations = model.itemsHook.updateFieldMany
+        ? `if (entry.ids.length === 1) {
+            void updateFieldMutation({ id: entry.ids[0], field: entry.field, value: entry.value } as Parameters<typeof updateFieldMutation>[0])
+          } else {
+            void updateFieldManyMutation({ ids: entry.ids, field: entry.field, value: entry.value } as Parameters<typeof updateFieldManyMutation>[0])
+          }`
+        : `for (const id of entry.ids) {
+            void updateFieldMutation({ id, field: entry.field, value: entry.value } as Parameters<typeof updateFieldMutation>[0])
+          }`;
+    const dependencies = model.itemsHook.updateFieldMany
+        ? '[filteredDataList, updateFieldMutation, updateFieldManyMutation]'
+        : '[filteredDataList, updateFieldMutation]';
+    return `// Batch cell updates: collect updates within the same microtask and send as one updateFieldMany
+  const pendingUpdatesRef = useRef<Map<string, { field: string; value: unknown; ids: ${model.types.id.name}[] }> | null>(null)
+
+  const handleCellUpdate = useCallback((args: { rowIndex: number; columnId: string; value: unknown }) => {
+    const row = filteredDataList?.[args.rowIndex]
+    if (!row) return
+
+    // Initialize batch map and schedule flush on first call in this microtask
+    if (!pendingUpdatesRef.current) {
+      pendingUpdatesRef.current = new Map()
+      queueMicrotask(() => {
+        const pending = pendingUpdatesRef.current
+        pendingUpdatesRef.current = null
+        if (!pending) return
+
+        for (const entry of pending.values()) {
+          ${flushMutations}
+        }
+      })
+    }
+
+    // Group by field+value so identical field updates across rows get batched
+    const key = \`\${args.columnId}::\${JSON.stringify(args.value)}\`
+    const existing = pendingUpdatesRef.current.get(key)
+    if (existing) {
+      existing.ids.push(row.id)
+    } else {
+      pendingUpdatesRef.current.set(key, { field: args.columnId, value: args.value, ids: [row.id] })
+    }
+  }, ${dependencies})`;
+}
+function buildRemoveRowsHandler(model) {
+    if (!model.itemsHook.deleteMany) {
+        return '';
+    }
+    return `function handleRemoveRows(rows: ${model.types.id.name}[]) {
+    void deleteManyMutation(rows)
+  }`;
+}
+function buildCommentSidebarTab({ showComments, model }) {
+    if (!showComments) {
+        return '';
+    }
+    return `<SidebarTab
+        side="right"
+        id="comment-content"
+        icon={MessageSquareText}
+        label="Comment"
+        order={0}
+        badge={{ label: String(commentCount) }}
+      >
+        <ModelCommentContent
+            model="${model.name}"
+            filteredIds={commentFilteredIds}
+            labelMap={commentLabelMap}
+            selectedEntityId={commentSelectedEntityId}
+            onCommentCountChange={setCommentCount}
+        />
+      </SidebarTab>`;
+}
+function buildRelatedTableProps(relatedModels) {
+    return relatedModels.map((rm) => `${rm.model.table.propName}={${rm.mapName}}`).join('\n              ');
+}
+function buildAddRowProp(model) {
+    if (model.isReadonly) {
+        return '';
+    }
+    return 'handleAddRow={() => setIsCreateModalOpen(true)}';
+}
+function buildCellUpdateProp(model) {
+    if (!model.itemsHook.updateField) {
+        return '';
+    }
+    return 'onCellUpdate={handleCellUpdate}';
+}
+function buildRemoveRowsProp(model) {
+    if (!model.itemsHook.deleteMany) {
+        return '';
+    }
+    return 'handleRemoveRows={handleRemoveRows}';
+}
+function resolveCreateModalContent(model, imports) {
+    if (!model.isReadonly) {
+        imports
+            .addType(model.types.id)
+            .addImport({ from: Generator.toPackageName('sonner'), items: [Generator.toFunctionName('toast')] })
+            .addImport({ from: model.forms.createModal.location, items: [model.forms.createModal.name] });
+        if (model.itemsHook.updateField) {
+            imports.addImport({ from: Generator.toPackageName('react'), items: [Generator.toFunctionName('useRef')] });
+        }
+        // In case the model does not provide any explicit label field, we generally use the id field as fallback.
+        // However, in case of creating a new item, we do not have an Id yet and hence cannot show it in success and error messages.
+        const hasLabelField = model.labelField.name !== model.idField.name;
+        const variableName = hasLabelField ? `created${model.name}` : '_';
+        const label = hasLabelField ? ` "\${${variableName}.${model.labelField.name}}"` : '';
+        return {
+            hook: ` const [isCreateModalOpen, setIsCreateModalOpen] = useState(false)`,
+            intentHook: `
+  useEffect(() => {
+    if (typeof globalThis === 'undefined') {
+      return
+    }
+
+    const storageKey = 'pxl:create-intent-model'
+    const targetModel = '${model.name}'
+    const openFromIntent = (intentModel: unknown) => {
+      if (intentModel === targetModel) {
+        setIsCreateModalOpen(true)
+        globalThis.sessionStorage.removeItem(storageKey)
+      }
+    }
+
+    openFromIntent(globalThis.sessionStorage.getItem(storageKey))
+
+    const onIntent = (event: Event) => {
+      const detail = (event as CustomEvent<{ model?: string }>).detail
+      openFromIntent(detail?.model)
+    }
+
+    globalThis.addEventListener('pxl:create-intent', onIntent)
+    return () => {
+      globalThis.removeEventListener('pxl:create-intent', onIntent)
+    }
+  }, [])`,
+            modal: `
+    <${model.forms.createModal.name}
+        open={isCreateModalOpen}
+        onClose={() => setIsCreateModalOpen(false)}
+        onSuccess={(${variableName}) => {
+          toast.success(\`${model.userFriendlyName}${label} created successfully!\`)
+          setIsCreateModalOpen(false)
+        }}
+        onError={(${variableName}, error) => {
+          toast.error(\`Error creating ${model.userFriendlyName}${label}: \${String(error)}\`)
+        }}
+      />`,
+        };
+    }
+    return { hook: '', intentHook: '', modal: '' };
+}
+function resolveSchemaRuleSet(model, context) {
+    for (const [schemaName, schemaRules] of context.schema.schemaAuth.entries()) {
+        if (schemaName === model.databaseSchema) {
+            return (schemaRules ?? {});
+        }
+    }
+    return {};
+}
+function resolveEffectiveRuleSet(model, context) {
+    const schemaRuleSet = resolveSchemaRuleSet(model, context);
+    const modelRuleSet = (model.auth ?? {});
+    return { ...schemaRuleSet, ...modelRuleSet };
+}
+function resolveWritePolicy(model, context) {
+    const effectiveRules = resolveEffectiveRuleSet(model, context);
+    const roles = effectiveRules.write?.anyRole;
+    if (roles) {
+        return { allowAll: false, roles };
+    }
+    // If create/update/delete are configured independently, use a conservative write gate:
+    // users must satisfy all configured operation role sets to see generic write UI controls.
+    const operationRoleSets = [
+        effectiveRules.create?.anyRole,
+        effectiveRules.update?.anyRole,
+        effectiveRules.delete?.anyRole,
+    ]
+        .filter((entry) => !!entry && entry.length > 0)
+        .map((entry) => Array.from(new Set(entry)));
+    if (operationRoleSets.length > 0) {
+        const [firstRoleSet, ...remainingRoleSets] = operationRoleSets;
+        if (!firstRoleSet) {
+            return { allowAll: !(context.schema.auth?.defaultDeny ?? true), roles: [] };
+        }
+        const intersection = remainingRoleSets.reduce((shared, current) => shared.filter((role) => current.includes(role)), firstRoleSet);
+        return { allowAll: false, roles: intersection };
+    }
+    return { allowAll: !(context.schema.auth?.defaultDeny ?? true), roles: [] };
+}
+function resolveAdminUiPolicy(model, context) {
+    const effectiveRules = resolveEffectiveRuleSet(model, context);
+    const roles = effectiveRules.adminUi?.visibleFor;
+    if (roles) {
+        return { allowAll: false, roles };
+    }
+    return { allowAll: !(context.schema.auth?.defaultDeny ?? true), roles: [] };
+}
 //# sourceMappingURL=model-admin-page.generator.js.map