@asteby/metacore-runtime-react 46.4.0 → 47.0.0

package/src/permissions-manager.tsx

@@ -73,7 +73,6 @@ import {
     Popover,
     PopoverContent,
     PopoverTrigger,
-    Separator,
     Skeleton,
     Collapsible,
     CollapsibleContent,
@@ -360,6 +359,31 @@ export function suggestRoleIcon(label: string): string {
     return 'Shield'
 }
 
+/** Label of the synthetic module that hosts the general (non-model) flags. */
+export const GENERAL_MODULE_LABEL = 'Permisos generales'
+
+/**
+ * The general flags (`general.work_after_hours`, …) as a synthetic module, so
+ * they are picked from the module combobox and edited in the same two-column
+ * action grid as any module's actions (#1021). Each flag keeps its full
+ * capability key through `PermissionActionDef.capability`.
+ */
+export function generalPermissionsModule(general: GeneralPermissionDef[]): PermissionModuleDef {
+    return {
+        key: 'general',
+        label: GENERAL_MODULE_LABEL,
+        icon: 'SlidersHorizontal',
+        kind: 'model',
+        actions: general.map((g) => ({
+            key: g.key.replace(/^general\./, ''),
+            label: g.label,
+            description: g.description,
+            capability: g.key,
+            kind: 'custom',
+        })),
+    }
+}
+
 /**
  * Normalize whatever `loadModules` returned into the canonical grouped shape.
  *
@@ -613,6 +637,15 @@ export function PermissionsManager({
 
     const allModules = React.useMemo(() => (groups ? flattenGroups(groups) : []), [groups])
 
+    // What the module picker lists: the catalog groups plus a trailing synthetic
+    // group for the general flags. `allModules` / "Otorgar todo" keep using the
+    // plain catalog, so that button's scope does not change.
+    const pickerGroups = React.useMemo<ModuleGroup[] | null>(() => {
+        if (!groups) return groups
+        if (!general || general.length === 0) return groups
+        return [...groups, { title: '', modules: [generalPermissionsModule(general)] }]
+    }, [groups, general])
+
     // ---- initial load: catalog + roles in parallel -------------------------
     React.useEffect(() => {
         let cancelled = false
@@ -670,8 +703,8 @@ export function PermissionsManager({
         [roles, activeRoleId],
     )
     const activeModule = React.useMemo(
-        () => moduleAtEntry(groups, activeModuleKey)?.module ?? null,
-        [groups, activeModuleKey],
+        () => moduleAtEntry(pickerGroups, activeModuleKey)?.module ?? null,
+        [pickerGroups, activeModuleKey],
     )
 
     const dirty = baseline !== null && draft !== null && !capabilitySetsEqual(baseline, draft)
@@ -841,8 +874,8 @@ export function PermissionsManager({
     const moduleTotal = activeModule?.actions.length ?? 0
     const checksDisabled = !activeRole || !draft || loadingPerms || saving
     const activeModuleGroupTitle = React.useMemo(
-        () => moduleAtEntry(groups, activeModuleKey)?.group.title ?? '',
-        [groups, activeModuleKey],
+        () => moduleAtEntry(pickerGroups, activeModuleKey)?.group.title ?? '',
+        [pickerGroups, activeModuleKey],
     )
 
     // ---- render --------------------------------------------------------------
@@ -1052,26 +1085,6 @@ export function PermissionsManager({
                                 )}
                             </div>
 
-                            {(general?.length ?? 0) > 0 && (
-                                <>
-                                    <Separator />
-                                    <div>
-                                        <h3 className="mb-2 text-sm font-semibold">Permisos Generales</h3>
-                                        <div className="flex flex-col gap-2">
-                                            {general!.map((g) => (
-                                                <CapabilityCheck
-                                                    key={g.key}
-                                                    checked={draft?.has(g.key) ?? false}
-                                                    disabled={checksDisabled}
-                                                    onToggle={() => toggleCapability(g.key)}
-                                                    label={g.label}
-                                                    description={g.description}
-                                                />
-                                            ))}
-                                        </div>
-                                    </div>
-                                </>
-                            )}
                         </CardContent>
                     </Card>
 
@@ -1122,7 +1135,7 @@ export function PermissionsManager({
                                         <CommandInput placeholder="Buscar módulo…" />
                                         <CommandList className="max-h-[360px]">
                                             <CommandEmpty>Sin módulos.</CommandEmpty>
-                                            {(groups ?? []).map((group, gi) => (
+                                            {(pickerGroups ?? []).map((group, gi) => (
                                                 <CommandGroup
                                                     key={group.title || `__untitled_${gi}`}
                                                     heading={group.title || undefined}

package/src/print-document-button.tsx

@@ -51,7 +51,15 @@ export function PrintDocumentButton({
             if (e.defaultPrevented) return
             setBusy(true)
             try {
-                await printDocument({ model, id, key: documentKey, mode, filename })
+                // A caller that handles errors itself keeps ownership of the error toast.
+                await printDocument({
+                    model,
+                    id,
+                    key: documentKey,
+                    mode,
+                    filename,
+                    feedback: onError ? { progress: true, success: true, error: false } : true,
+                })
             } catch (err) {
                 onError?.(err)
             } finally {

package/src/record-mutation-events.ts

@@ -0,0 +1,50 @@
+// record-mutation-events — a tiny window-level bus that tells every mounted
+// list (DynamicTable, DynamicKanban) "a record of model X just changed".
+//
+// Why: the lists only reloaded when the *caller* bumped `refreshTrigger`. A
+// create/edit/delete done from a dialog the shell opens (the dynamic record
+// dialog, a federated action modal, a wizard, a confirmation) never reached
+// the table, so the row stayed stale until a manual refresh (#1020). Emitting
+// here decouples the mutation site from the list that displays the model.
+
+export type RecordMutationKind = 'create' | 'update' | 'delete'
+
+export const RECORD_MUTATION_EVENT = 'metacore:record-mutated'
+
+export interface RecordMutationDetail {
+    /** Model key as the emitter knows it (matched case-insensitively). */
+    model: string
+    kind: RecordMutationKind
+}
+
+const norm = (m: string | undefined | null) => (m ?? '').trim().toLowerCase()
+
+/** Announce a successful mutation. Safe to call outside a browser (no-op). */
+export function emitRecordMutation(model: string | undefined | null, kind: RecordMutationKind): void {
+    if (!model || typeof window === 'undefined' || typeof CustomEvent === 'undefined') return
+    try {
+        window.dispatchEvent(
+            new CustomEvent<RecordMutationDetail>(RECORD_MUTATION_EVENT, { detail: { model, kind } }),
+        )
+    } catch {
+        /* a listener must never break the save flow */
+    }
+}
+
+/**
+ * Listen for mutations of `model` (case-insensitive). Returns an unsubscribe.
+ */
+export function subscribeRecordMutations(
+    model: string | undefined | null,
+    cb: (detail: RecordMutationDetail) => void,
+): () => void {
+    if (typeof window === 'undefined') return () => {}
+    const want = norm(model)
+    const handler = (e: Event) => {
+        const d = (e as CustomEvent<RecordMutationDetail>).detail
+        if (!d || !want || norm(d.model) !== want) return
+        cb(d)
+    }
+    window.addEventListener(RECORD_MUTATION_EVENT, handler)
+    return () => window.removeEventListener(RECORD_MUTATION_EVENT, handler)
+}

package/src/types.ts

@@ -22,6 +22,48 @@ export interface ImportSpecMeta {
     instructions?: string[]
 }
 
+/** Paso de renglones de un tipo de documento (usa el editor de renglones del SDK). */
+export interface DocumentFormLines {
+    /** Campo del payload que recibe los renglones. Default: `lines` (o `lines_field` del manifest). */
+    field?: string
+    /** Columnas opcionales del editor (`discount`, `tax`, `unit`…). */
+    columns?: string[]
+    /** `sale` (precio de lista) o `cost` (compras). Default `sale`. */
+    price_source?: 'sale' | 'cost'
+    /** Al menos un renglón para guardar. Default true. */
+    required?: boolean
+    /** Título del paso. Default «Renglones». */
+    title?: string
+}
+
+/** Un tipo de documento (Factura, Nota de crédito, REP, Global, Traslado…). */
+export interface DocumentFormType {
+    key: string
+    label: string
+    description?: string
+    icon?: string
+    /** Valor que se escribe en `type_field` (p. ej. `"E"`). Default: `key`. */
+    value?: string
+    /** Campos del tipo, en el mismo vocabulario que los campos de una acción. */
+    fields: ActionFieldDef[]
+    /** Valores fijos que viajan en el alta de este tipo. */
+    defaults?: Record<string, unknown>
+    /** Con esto el tipo tiene paso de renglones. */
+    lines?: DocumentFormLines | boolean
+    /** Endpoint de alta propio de este tipo. Default: el del modelo. */
+    endpoint?: string
+    /** Texto del botón final. Default «Crear». */
+    submit_label?: string
+}
+
+export interface DocumentFormsManifest {
+    /** Columna discriminadora del modelo (p. ej. `"type"`). Sin ella no se escribe el tipo. */
+    type_field?: string
+    /** Campo por defecto de los renglones. Default `lines`. */
+    lines_field?: string
+    types: DocumentFormType[]
+}
+
 export interface TableMetadata {
     title: string
     endpoint: string
@@ -36,6 +78,13 @@ export interface TableMetadata {
     canExport?: boolean
     canImport?: boolean
     canCreate?: boolean
+    /**
+     * Formularios de alta guiados por tipo de documento (FAC-12). Cuando trae
+     * al menos un tipo, `DynamicCRUDPage` abre `DocumentFormDialog` en lugar del
+     * formulario genérico del modelo. Lo sirve el kernel o el addon; el SDK no
+     * conoce campos fiscales.
+     */
+    document_forms?: DocumentFormsManifest
     /**
      * Cómo se pinta el alta genérica. `generic` (o ausente) es el botón Crear.
      * `hidden` lo quita. `action` lo quita porque el módulo trae la suya

package/src/use-print-document.ts

@@ -17,6 +17,7 @@
 // The ApiClient is a PEER via <ApiProvider> (same one useAddonSettings uses), so
 // this hook constructs no client of its own.
 import { useCallback } from 'react'
+import { toast } from 'sonner'
 import { useApi } from './api-context'
 
 export interface PrintDocumentArgs {
@@ -40,6 +41,42 @@ export interface PrintDocumentArgs {
      * that is how downloads end up literally named with mustache braces.
      */
     filename?: string
+    /**
+     * User feedback. Default: a toast while the file is prepared, a success toast
+     * when it is ready and an error toast with the server's reason when it fails
+     * (a download used to give NO sign of life — PIT «Descargar Factura CFDI»).
+     * `false` silences all of it; `{ error: false }` leaves errors to the caller
+     * (the promise still rejects either way).
+     */
+    feedback?: boolean | { progress?: boolean; success?: boolean; error?: boolean }
+}
+
+const noun = (mode: 'print' | 'download' | 'open') =>
+    mode === 'download' ? 'Descargando documento…' : mode === 'open' ? 'Abriendo documento…' : 'Preparando impresión…'
+
+const readyMessage = (mode: 'print' | 'download' | 'open') =>
+    mode === 'download' ? 'Documento descargado' : mode === 'open' ? 'Documento abierto' : 'Documento listo para imprimir'
+
+/** Best-effort message from an error whose body is a Blob (responseType: 'blob'). */
+export async function documentErrorMessage(err: unknown): Promise<string> {
+    const fallback = 'No se pudo generar el documento. Inténtalo de nuevo.'
+    const e = err as { response?: { data?: unknown; status?: number }; message?: unknown } | undefined
+    let data = e?.response?.data
+    try {
+        if (typeof Blob !== 'undefined' && data instanceof Blob) {
+            data = JSON.parse(await data.text())
+        }
+    } catch {
+        data = undefined
+    }
+    const d = data as { message?: unknown; details?: unknown; error?: unknown } | string | undefined
+    if (typeof d === 'string' && d.trim()) return d.trim().slice(0, 200)
+    if (d && typeof d === 'object') {
+        const msg = [d.message, d.details, d.error].find((x) => typeof x === 'string' && x.trim()) as string | undefined
+        if (msg) return msg.trim()
+    }
+    if (e?.response?.status === 404) return 'El documento no está disponible todavía.'
+    return fallback
 }
 
 /** Parse filename from Content-Disposition (RFC 5987 / quoted). */
@@ -71,14 +108,14 @@ export function looksLikeFilenameTemplate(name: string | undefined): boolean {
  */
 export function usePrintDocument() {
     const api = useApi()
-    return useCallback(
+    const run = useCallback(
         async ({
             model,
             id,
             key,
-            mode = 'print',
+            mode,
             filename,
-        }: PrintDocumentArgs): Promise<string> => {
+        }: Required<Pick<PrintDocumentArgs, 'model' | 'id' | 'key' | 'mode'>> & Pick<PrintDocumentArgs, 'filename'>): Promise<string> => {
             const url = `/data/${encodeURIComponent(model)}/${encodeURIComponent(
                 id,
             )}/documents/${encodeURIComponent(key)}.pdf`
@@ -145,4 +182,30 @@ export function usePrintDocument() {
         },
         [api],
     )
+    return useCallback(
+        async ({
+            model,
+            id,
+            key,
+            mode = 'print',
+            filename,
+            feedback = true,
+        }: PrintDocumentArgs): Promise<string> => {
+            const fb = feedback === false ? {} : feedback === true ? { progress: true, success: true, error: true } : feedback
+            const toastId = fb.progress ? toast.loading(noun(mode)) : undefined
+            try {
+                const blobUrl = await run({ model, id, key, mode, filename })
+                if (toastId !== undefined) toast.dismiss(toastId)
+                if (fb.success) toast.success(readyMessage(mode))
+                return blobUrl
+            } catch (err) {
+                if (toastId !== undefined) toast.dismiss(toastId)
+                if (fb.error) toast.error(await documentErrorMessage(err))
+                throw err
+            } finally {
+                if (toastId !== undefined) toast.dismiss(toastId)
+            }
+        },
+        [run],
+    )
 }

package/src/use-record-mutation-tick.ts

@@ -0,0 +1,12 @@
+import { useEffect, useState } from 'react'
+import { subscribeRecordMutations } from './record-mutation-events'
+
+/**
+ * A counter that increments whenever a record of `model` is created, updated
+ * or deleted anywhere in the app. Fold it into a list's refetch deps.
+ */
+export function useRecordMutationTick(model: string | undefined | null): number {
+    const [tick, setTick] = useState(0)
+    useEffect(() => subscribeRecordMutations(model, () => setTick((n) => n + 1)), [model])
+    return tick
+}