@asteby/metacore-runtime-react 39.2.8 → 39.2.9

package/src/dynamic-date-field.tsx

@@ -21,6 +21,7 @@ import {
 } from '@asteby/metacore-ui/primitives'
 import { CalendarIcon } from 'lucide-react'
 import type { ActionFieldDef } from './types'
+import { parseCalendarDate } from './calendar-date'
 
 export interface DynamicDateFieldProps {
     field: ActionFieldDef
@@ -28,16 +29,7 @@ export interface DynamicDateFieldProps {
     onChange: (v: any) => void
 }
 
-// Parse "YYYY-MM-DD" (or any Date-parseable string) into a local Date, or
-// undefined when empty/invalid. Uses noon to dodge timezone day-shift.
-function toDate(v: any): Date | undefined {
-    if (!v) return undefined
-    const s = String(v)
-    const m = /^(\d{4})-(\d{2})-(\d{2})/.exec(s)
-    if (m) return new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3]), 12)
-    const d = new Date(s)
-    return isNaN(d.getTime()) ? undefined : d
-}
+const toDate = parseCalendarDate
 
 // Format a Date back to "YYYY-MM-DD" (local, no timezone shift).
 function toISO(d: Date): string {

package/src/index.ts

@@ -400,6 +400,7 @@ export {
     optionsBatchToken,
     optionsModelFromUrl,
     rememberInRows,
+    invalidateQueryBatchData,
     resetQueryBatchCache,
     splitInToken,
     tokenForGet,
@@ -409,6 +410,7 @@ export {
 } from './query-batch'
 export {
     useOptionsResolver,
+    invalidateOptionsCache,
     projectOption,
     type ResolvedOption,
     type OptionsMeta,

package/src/permissions-manager.tsx

@@ -38,6 +38,7 @@ import {
     Trash2,
 } from 'lucide-react'
 import { toast } from 'sonner'
+import { extractServerError } from './server-error'
 import { cn } from '@asteby/metacore-ui/lib'
 import {
     AlertDialog,
@@ -397,6 +398,29 @@ export function normalizeCatalogGroups(catalog: PermissionsCatalog): ModuleGroup
 }
 
 /** Flat list of every module across groups, in render order. */
+/** Identity of one picker entry: its group index and its index in the group. */
+export function moduleEntryId(groupIndex: number, moduleIndex: number): string {
+    return `${groupIndex}:${moduleIndex}`
+}
+
+/** The first entry of the catalog, or null when it has no modules. */
+export function firstModuleEntryId(groups: ModuleGroup[]): string | null {
+    const gi = groups.findIndex((g) => g.modules.length > 0)
+    return gi < 0 ? null : moduleEntryId(gi, 0)
+}
+
+/** Resolve an entry id back to its module and group. */
+export function moduleAtEntry(
+    groups: ModuleGroup[] | null | undefined,
+    id: string | null,
+): { module: PermissionModuleDef; group: ModuleGroup } | null {
+    if (!groups || !id) return null
+    const [gi, mi] = id.split(':').map(Number)
+    const group = groups[gi!]
+    const module = group?.modules[mi!]
+    return group && module ? { module, group } : null
+}
+
 export function flattenGroups(groups: ModuleGroup[]): PermissionModuleDef[] {
     return groups.flatMap((g) => g.modules)
 }
@@ -546,6 +570,10 @@ export function PermissionsManager({
     const [loadError, setLoadError] = React.useState(false)
 
     const [activeRoleId, setActiveRoleId] = React.useState<string | null>(null)
+    // The picker selection is the ENTRY (group index : module index), not the
+    // module key: two sidebar entries may govern the same model (e.g. "Ventas
+    // POS" and "Por cobrar" both over sales_orders) and a key-based lookup
+    // always landed on the first of them.
     const [activeModuleKey, setActiveModuleKey] = React.useState<string | null>(null)
 
     // baseline = capabilities as persisted; draft = baseline + local edits.
@@ -567,6 +595,8 @@ export function PermissionsManager({
         color: string
         icon: string
         grantAll: boolean
+        /** Server rejection shown inside the dialog (e.g. duplicate name). */
+        error?: string
     }>({
         open: false,
         mode: 'create',
@@ -594,9 +624,7 @@ export function PermissionsManager({
                 setGeneral(cat.general ?? [])
                 setRoles(rs)
                 setActiveRoleId((prev) => prev ?? rs[0]?.id ?? null)
-                setActiveModuleKey(
-                    (prev) => prev ?? flattenGroups(grouped)[0]?.key ?? null,
-                )
+                setActiveModuleKey((prev) => prev ?? firstModuleEntryId(grouped))
             })
             .catch(() => {
                 if (!cancelled) setLoadError(true)
@@ -642,8 +670,8 @@ export function PermissionsManager({
         [roles, activeRoleId],
     )
     const activeModule = React.useMemo(
-        () => allModules.find((m) => m.key === activeModuleKey) ?? null,
-        [allModules, activeModuleKey],
+        () => moduleAtEntry(groups, activeModuleKey)?.module ?? null,
+        [groups, activeModuleKey],
     )
 
     const dirty = baseline !== null && draft !== null && !capabilitySetsEqual(baseline, draft)
@@ -730,6 +758,7 @@ export function PermissionsManager({
         const label = roleDialog.label.trim()
         if (!label) return
         setRoleSaving(true)
+        setRoleDialog((d) => ({ ...d, error: undefined }))
         try {
             if (roleDialog.mode === 'create' && createRole) {
                 const created = await createRole({
@@ -764,10 +793,15 @@ export function PermissionsManager({
                 toast.success('Rol actualizado')
             }
             setRoleDialog((d) => ({ ...d, open: false }))
-        } catch {
-            toast.error(
-                roleDialog.mode === 'create' ? 'No se pudo crear el rol' : 'No se pudo actualizar el rol',
-            )
+        } catch (err) {
+            // Keep the dialog open WITH the server's reason (422 duplicate name,
+            // 403 …): a toast alone can sit behind the modal overlay.
+            const fallback =
+                roleDialog.mode === 'create' ? 'No se pudo crear el rol' : 'No se pudo actualizar el rol'
+            const { title, description } = extractServerError(err, fallback)
+            const error = description ? `${title}: ${description}` : title
+            setRoleDialog((d) => ({ ...d, error }))
+            toast.error(fallback, { description: error })
         } finally {
             setRoleSaving(false)
         }
@@ -806,11 +840,10 @@ export function PermissionsManager({
     const moduleGranted = activeModule && draft ? grantedCountForModule(draft, activeModule) : 0
     const moduleTotal = activeModule?.actions.length ?? 0
     const checksDisabled = !activeRole || !draft || loadingPerms || saving
-    const activeModuleGroupTitle = React.useMemo(() => {
-        if (!activeModule || !groups) return ''
-        const g = groups.find((grp) => grp.modules.some((m) => m.key === activeModule.key))
-        return g?.title ?? ''
-    }, [activeModule, groups])
+    const activeModuleGroupTitle = React.useMemo(
+        () => moduleAtEntry(groups, activeModuleKey)?.group.title ?? '',
+        [groups, activeModuleKey],
+    )
 
     // ---- render --------------------------------------------------------------
     if (loadError) {
@@ -1094,12 +1127,12 @@ export function PermissionsManager({
                                                     key={group.title || `__untitled_${gi}`}
                                                     heading={group.title || undefined}
                                                 >
-                                                    {group.modules.map((mod) => (
+                                                    {group.modules.map((mod, mi) => (
                                                         <CommandItem
-                                                            key={mod.key}
-                                                            value={`${group.title} ${mod.label} ${mod.key}`}
+                                                            key={moduleEntryId(gi, mi)}
+                                                            value={`${group.title} ${mod.label} ${mod.key} ${moduleEntryId(gi, mi)}`}
                                                             onSelect={() => {
-                                                                setActiveModuleKey(mod.key)
+                                                                setActiveModuleKey(moduleEntryId(gi, mi))
                                                                 setModuleOpen(false)
                                                             }}
                                                         >
@@ -1129,7 +1162,7 @@ export function PermissionsManager({
                                                                         /{mod.actions.length}
                                                                     </Badge>
                                                                 )}
-                                                            {mod.key === activeModuleKey && (
+                                                            {moduleEntryId(gi, mi) === activeModuleKey && (
                                                                 <Check className="ml-2 h-4 w-4 shrink-0" />
                                                             )}
                                                         </CommandItem>
@@ -1270,6 +1303,7 @@ export function PermissionsManager({
                                     setRoleDialog((d) => ({
                                         ...d,
                                         label,
+                                        error: undefined,
                                         icon:
                                             d.icon === suggestRoleIcon(d.label) ||
                                             d.icon === 'Shield' ||
@@ -1330,6 +1364,11 @@ export function PermissionsManager({
                                 </span>
                             </label>
                         )}
+                        {roleDialog.error && (
+                            <p role="alert" className="text-sm text-destructive">
+                                {roleDialog.error}
+                            </p>
+                        )}
                     </div>
                     <DialogFooter>
                         <Button

package/src/query-batch.test.ts

@@ -1,5 +1,7 @@
-import { describe, expect, it } from 'vitest'
+import { describe, expect, it, vi } from 'vitest'
 import {
+    invalidateQueryBatchData,
+    loadQueryPart,
     nameBatchTokens,
     narrowInToken,
     optionsBatchToken,
@@ -64,4 +66,79 @@ describe('query batch tokens', () => {
         expect(tokenForGet('/data/Stock/me')).toBeNull()
         expect(tokenForGet('/options/Customer?field=name&q=lop')).toBe('o:Customer?field=name&q=lop')
     })
+
+    it('keeps every row of an id and reads f_ filters by their column', () => {
+        resetQueryBatchCache()
+        const token = 't:Stock?f_product_id=in:a,b&per_page=200'
+        rememberInRows(token, ['a', 'b'], [
+            { product_id: 'a', warehouse_id: 'w1' },
+            { product_id: 'a', warehouse_id: 'w2' },
+            { product_id: 'b', warehouse_id: 'w1' },
+        ])
+        const done = narrowInToken(token)
+        expect(done?.wire).toBe('')
+        expect(done?.rows).toHaveLength(3)
+        resetQueryBatchCache()
+    })
+
+    it('does not split a paginated list', () => {
+        expect(splitInToken('t:Stock?f_product_id=in:a,b&page=1&per_page=25')).toBeNull()
+    })
+})
+
+describe('query batch freshness', () => {
+    function fakeApi(responses: unknown[]) {
+        const post = vi.fn(async (_url: string, body: { parts: string[]; inm: Record<string, string> }) => {
+            const next = responses.shift() as (b: typeof body) => unknown
+            return { data: next(body) }
+        })
+        return { post, get: vi.fn(), put: vi.fn(), delete: vi.fn() }
+    }
+
+    it('reads a list again instead of serving it from memory', async () => {
+        resetQueryBatchCache()
+        const api = fakeApi([
+            () => ({ success: true, parts: { q1: { success: true, data: [], etag: '"q-1-2"' } } }),
+            (body: { inm: Record<string, string> }) => {
+                // A length-based etag is not trusted: the stale copy is not offered.
+                expect(body.inm).toEqual({})
+                return { success: true, parts: { q1: { success: true, data: [{ id: 'x' }], etag: '"q-1-2"' } } }
+            },
+        ])
+        const token = 't:QuoteItem?f_quote_id=eq%3Aq1&page=1&per_page=25'
+        expect((await loadQueryPart(api as never, token)).data).toEqual([])
+        expect((await loadQueryPart(api as never, token)).data).toEqual([{ id: 'x' }])
+        expect(api.post).toHaveBeenCalledTimes(2)
+        resetQueryBatchCache()
+    })
+
+    it('reuses a list only when the content etag says it did not change', async () => {
+        resetQueryBatchCache()
+        const api = fakeApi([
+            () => ({ success: true, parts: { q1: { success: true, data: [{ id: 'x' }], etag: '"qh-abc"' } } }),
+            (body: { inm: Record<string, string> }) => {
+                expect(body.inm).toEqual({ q1: '"qh-abc"' })
+                return { success: true, parts: { q1: { success: true, not_modified: true, etag: '"qh-abc"' } } }
+            },
+        ])
+        const token = 't:QuoteItem?page=1'
+        await loadQueryPart(api as never, token)
+        expect((await loadQueryPart(api as never, token)).data).toEqual([{ id: 'x' }])
+        resetQueryBatchCache()
+    })
+
+    it('forgets remembered rows after a mutation but keeps metadata', async () => {
+        resetQueryBatchCache()
+        const api = fakeApi([
+            () => ({ success: true, parts: { q1: { success: true, data: { columns: [] } } } }),
+        ])
+        await loadQueryPart(api as never, 'm:Quote')
+        rememberInRows('t:Stock?product_id=in:a', ['a'], [{ product_id: 'a' }])
+        invalidateQueryBatchData()
+        expect(narrowInToken('t:Stock?product_id=in:a')).toBeNull()
+        // Metadata is still served from memory: no second request.
+        await loadQueryPart(api as never, 'm:Quote')
+        expect(api.post).toHaveBeenCalledTimes(1)
+        resetQueryBatchCache()
+    })
 })

package/src/query-batch.ts

@@ -31,7 +31,26 @@ type Waiter = {
 }
 
 type CachedPart = { part: QueryPart; at: number }
-type CachedEntity = { row: Record<string, unknown> | null; at: number }
+type CachedEntity = { rows: Record<string, unknown>[]; at: number }
+
+/**
+ * Only metadata and i18n are served from memory without asking the server.
+ * Rows (`t:` lists, `r:` records) and options change with every save: they
+ * always travel, and an unchanged payload comes back as `not_modified` when
+ * the server's etag hashes the content.
+ */
+function servedFromMemory(token: string): boolean {
+    return token.startsWith('m:') || token.startsWith('mm:') || token.startsWith('i:')
+}
+
+/**
+ * Etags the server derives from the payload itself (`"qh-…"`). The older
+ * `"q-<seed>-<len>"` ones only counted rows or bytes, so a value edited to one
+ * of the same length came back `not_modified` with the old data.
+ */
+function contentEtag(etag: string | undefined): boolean {
+    return !!etag && etag.startsWith('"qh-')
+}
 
 const partCache = new Map<string, CachedPart>()
 const entityCache = new Map<string, CachedEntity>()
@@ -42,13 +61,18 @@ export interface InListToken {
     shape: string
 }
 
-/** A concrete `t:` `in:` list. `@` references stay whole: the ids are not known yet. */
+/**
+ * A concrete `t:` `in:` list. `@` references stay whole: the ids are not known
+ * yet. A paginated list (`page=`) is not split: serving part of it from memory
+ * would change which rows land on the page and the total.
+ */
 export function splitInToken(token: string): InListToken | null {
     const q = token.indexOf('?')
     if (q < 0 || !token.startsWith('t:')) return null
     const model = token.slice(2, q)
     if (!/^[A-Za-z][A-Za-z0-9_]*$/.test(model)) return null
     const params = new URLSearchParams(token.slice(q + 1))
+    if (params.has('page')) return null
     let field = ''
     let ids: string[] = []
     for (const [key, value] of params.entries()) {
@@ -71,6 +95,11 @@ function entityKey(scope: string, shape: string, id: string): string {
     return `${scope}\n${shape}\n${id}`
 }
 
+/** The row column an `in:` filter matches: `f_product_id` filters `product_id`. */
+function rowField(param: string): string {
+    return param.startsWith('f_') ? param.slice(2) : param
+}
+
 function replaceInIds(token: string, field: string, ids: string[]): string {
     const q = token.indexOf('?')
     const params = new URLSearchParams(token.slice(q + 1))
@@ -99,7 +128,7 @@ export function narrowInToken(token: string, now = Date.now()): NarrowedIn | nul
             missingIds.push(id)
             continue
         }
-        if (hit.row) rows.push(hit.row)
+        rows.push(...hit.rows)
     }
     if (missingIds.length === parsed.ids.length) return null
     return {
@@ -111,7 +140,11 @@ export function narrowInToken(token: string, now = Date.now()): NarrowedIn | nul
     }
 }
 
-/** Stores one row per requested id. An id with no row is remembered as empty. */
+/**
+ * Stores every row of each requested id (one id can match many rows: the
+ * stock of a product in several warehouses). An id with no row is remembered
+ * as empty.
+ */
 export function rememberInRows(
     token: string,
     ids: string[],
@@ -121,22 +154,19 @@ export function rememberInRows(
     const parsed = splitInToken(token)
     if (!parsed) return
     const scope = cacheScope()
-    const seen = new Set<string>()
+    const field = rowField(parsed.field)
+    const byId = new Map<string, Record<string, unknown>[]>()
+    for (const id of ids) byId.set(id, [])
     if (Array.isArray(rows)) {
         for (const row of rows) {
             if (!row || typeof row !== 'object') continue
-            const id = String((row as Record<string, unknown>)[parsed.field] ?? '').trim()
-            if (!id) continue
-            seen.add(id)
-            entityCache.set(entityKey(scope, parsed.shape, id), {
-                row: row as Record<string, unknown>,
-                at: now,
-            })
+            const id = String((row as Record<string, unknown>)[field] ?? '').trim()
+            const bucket = byId.get(id)
+            if (bucket) bucket.push(row as Record<string, unknown>)
         }
     }
-    for (const id of ids) {
-        if (seen.has(id)) continue
-        entityCache.set(entityKey(scope, parsed.shape, id), { row: null, at: now })
+    for (const [id, bucket] of byId) {
+        entityCache.set(entityKey(scope, parsed.shape, id), { rows: bucket, at: now })
     }
 }
 
@@ -147,6 +177,19 @@ export function resetQueryBatchCache(): void {
     if (timer != null) clearTimeout(timer)
     timer = null
 }
+
+/**
+ * Forgets every row, record and option read. useApi calls it after each
+ * mutation so the list that just gained, changed or lost a row reads it
+ * again instead of the copy from before the save. Metadata and i18n stay.
+ */
+export function invalidateQueryBatchData(): void {
+    for (const key of [...partCache.keys()]) {
+        const token = key.slice(key.indexOf('\n') + 1)
+        if (!servedFromMemory(token)) partCache.delete(key)
+    }
+    entityCache.clear()
+}
 let waiters: Waiter[] = []
 let timer: ReturnType<typeof setTimeout> | null = null
 let transport: ApiClient | null = null
@@ -205,7 +248,7 @@ export function nameBatchTokens(tokens: string[]): { name: string; token: string
 
 export function loadQueryPart(api: ApiClient, token: string): Promise<QueryPart> {
     const cached = partCache.get(`${cacheScope()}\n${token}`)
-    if (cached && Date.now() - cached.at < PART_TTL_MS && cached.part.success) {
+    if (cached && servedFromMemory(token) && Date.now() - cached.at < PART_TTL_MS && cached.part.success) {
         return Promise.resolve(cached.part)
     }
     const narrowed = narrowInToken(token)
@@ -239,7 +282,8 @@ async function flushQueryBatch() {
     const scope = cacheScope()
     for (const part of named) {
         const cached = partCache.get(`${scope}\n${part.token}`)
-        if (cached?.part.etag) inm[part.name] = cached.part.etag
+        const etag = cached?.part.etag
+        if (etag && (servedFromMemory(part.token) || contentEtag(etag))) inm[part.name] = etag
     }
     try {
         const res = await api.post('/q', { parts: named.map((part) => part.plan), inm })
@@ -257,9 +301,14 @@ async function flushQueryBatch() {
             if (part.not_modified) {
                 const cached = partCache.get(`${scope}\n${waiter.token}`)
                 if (cached) {
+                    cached.at = Date.now()
                     waiter.resolve(cached.part)
                     continue
                 }
+                // Invalidated while the request was in flight: nothing to
+                // reuse, so batchGet falls back to the plain GET.
+                waiter.reject(new Error('batch part not modified but not cached'))
+                continue
             }
             const merged = mergeCachedRows(waiter.cachedRows, part)
             if (waiter.missingIds && waiter.field) {

package/src/use-options-resolver.ts

@@ -113,6 +113,20 @@ type OptionsPayload = { options: ResolvedOption[]; meta: OptionsMeta }
 const optionsCache = new Map<string, { payload: OptionsPayload; at: number }>()
 const optionsInflight = new Map<string, Promise<OptionsPayload>>()
 const optionsEpoch = new Map<string, number>()
+// Bumped by invalidateOptionsCache: a lookup that started before a write must
+// not store what it read.
+let optionsGeneration = 0
+
+/**
+ * Forgets every cached and in-flight options lookup. Called after any write
+ * (create, edit, delete), so a picker opened right after creating a record
+ * lists it instead of serving the previous 30 s snapshot.
+ */
+export function invalidateOptionsCache(): void {
+    optionsGeneration++
+    optionsCache.clear()
+    optionsInflight.clear()
+}
 
 export function optionsRequestKey(
     scope: string,
@@ -220,6 +234,7 @@ export function useOptionsResolver(args: UseOptionsResolverArgs): UseOptionsReso
             optionsInflight.delete(key)
         }
         const epoch = optionsEpoch.get(key) ?? 0
+        const generation = optionsGeneration
         const cached = optionsCache.get(key)
         if (cached && Date.now() - cached.at < OPTIONS_TTL_MS) {
             setOptions(cached.payload.options)
@@ -254,7 +269,7 @@ export function useOptionsResolver(args: UseOptionsResolverArgs): UseOptionsReso
                             data: part.data,
                             meta: part.meta,
                         })
-                        if ((optionsEpoch.get(key) ?? 0) === epoch) {
+                        if ((optionsEpoch.get(key) ?? 0) === epoch && optionsGeneration === generation) {
                             optionsCache.set(key, { payload, at: Date.now() })
                         }
                         return payload
@@ -270,7 +285,7 @@ export function useOptionsResolver(args: UseOptionsResolverArgs): UseOptionsReso
                     throw new Error(body?.message || 'options resolver: unsuccessful response')
                 }
                 const payload = readOptionsEnvelope(body)
-                if ((optionsEpoch.get(key) ?? 0) === epoch) {
+                if ((optionsEpoch.get(key) ?? 0) === epoch && optionsGeneration === generation) {
                     optionsCache.set(key, { payload, at: Date.now() })
                 }
                 return payload

package/src/validation-catalog.ts

@@ -22,6 +22,7 @@ export const VALIDATION_CATALOGS: Record<string, Record<string, string>> = {
         integer: '{{label}} debe ser un entero',
         custom: '{{label}} no es válido',
         line_items_required: '{{label}} requiere al menos un renglón',
+        protected_field: 'El campo {{label}} lo administra el sistema y no se puede modificar',
         fallback: '{{label}}: valor inválido',
     },
     en: {
@@ -43,6 +44,7 @@ export const VALIDATION_CATALOGS: Record<string, Record<string, string>> = {
         integer: 'The {{label}} must be an integer',
         custom: 'The {{label}} is invalid',
         line_items_required: '{{label}} requires at least one row',
+        protected_field: 'The {{label}} field is managed by the system and cannot be changed',
         fallback: '{{label}}: invalid value',
     },
 }