@asteby/metacore-runtime-react 39.2.7 → 39.2.9

package/src/query-batch.test.ts

@@ -1,5 +1,16 @@
-import { describe, expect, it } from 'vitest'
-import { nameBatchTokens, optionsBatchToken, optionsModelFromUrl } from './query-batch'
+import { describe, expect, it, vi } from 'vitest'
+import {
+    invalidateQueryBatchData,
+    loadQueryPart,
+    nameBatchTokens,
+    narrowInToken,
+    optionsBatchToken,
+    optionsModelFromUrl,
+    rememberInRows,
+    resetQueryBatchCache,
+    splitInToken,
+    tokenForGet,
+} from './query-batch'
 
 describe('query batch tokens', () => {
     it('names distinct tokens and keeps duplicates as one part', () => {
@@ -21,4 +32,113 @@ describe('query batch tokens', () => {
             'o:Customer?field=id&q=lop&limit=20',
         )
     })
+
+    it('keeps each in: id and asks only for the ones that are missing', () => {
+        resetQueryBatchCache()
+        const token = 't:Stock?per_page=200&product_id=in:a,b,c&skip_refs=1'
+        expect(splitInToken(token)?.shape).toBe('t:Stock?per_page=200&product_id=in:$1&skip_refs=1')
+        expect(splitInToken('t:Stock?product_id=in:@p1.id')).toBeNull()
+
+        rememberInRows(token, ['a', 'b'], [{ product_id: 'a', quantity: 1 }])
+        const narrowed = narrowInToken(token)
+        expect(narrowed?.missingIds).toEqual(['c'])
+        expect(narrowed?.rows).toEqual([{ product_id: 'a', quantity: 1 }])
+        expect(narrowed?.wire).toContain('in%3Ac')
+        expect(narrowed?.wire).not.toContain('%2Cb')
+
+        rememberInRows(token, ['c'], [{ product_id: 'c', quantity: 4 }])
+        const done = narrowInToken('t:Stock?product_id=in:a,c&per_page=200&skip_refs=1')
+        expect(done?.wire).toBe('')
+        expect(done?.rows).toEqual([
+            { product_id: 'a', quantity: 1 },
+            { product_id: 'c', quantity: 4 },
+        ])
+        resetQueryBatchCache()
+    })
+
+    it('maps table reads onto batch tokens and leaves aggregates on GET', () => {
+        expect(tokenForGet('/metadata/table/Sale')).toBe('m:Sale')
+        expect(tokenForGet('/metadata/modal/Sale')).toBe('mm:Sale')
+        expect(tokenForGet('/data/Stock', { per_page: 20, page: 1, 'f_product_id': 'in:a,b' })).toBe(
+            't:Stock?f_product_id=in%3Aa%2Cb&page=1&per_page=20',
+        )
+        expect(tokenForGet('/data/Stock/aggregate', { page: 1 })).toBeNull()
+        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

@@ -18,20 +18,188 @@ export interface QueryPart {
 
 const WINDOW_MS = 8
 const PART_TTL_MS = 30_000
+const ENTITY_TTL_MS = 30_000
 
 type Waiter = {
     token: string
+    wire: string
     resolve: (part: QueryPart) => void
     reject: (error: Error) => void
+    cachedRows?: Record<string, unknown>[]
+    missingIds?: string[]
+    field?: string
 }
 
 type CachedPart = { part: QueryPart; 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>()
+
+export interface InListToken {
+    field: string
+    ids: string[]
+    shape: string
+}
+
+/**
+ * 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()) {
+        if (!value.startsWith('in:')) continue
+        if (field || value.includes('@')) return null
+        field = key
+        ids = value
+            .slice(3)
+            .split(',')
+            .map((id) => id.trim())
+            .filter(Boolean)
+    }
+    if (!field || ids.length === 0) return null
+    const keys = [...new Set(params.keys())].sort()
+    const bits = keys.map((key) => `${key}=${key === field ? 'in:$1' : (params.get(key) ?? '')}`)
+    return { field, ids, shape: `t:${model}?${bits.join('&')}` }
+}
+
+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))
+    params.set(field, `in:${ids.join(',')}`)
+    return `${token.slice(0, q)}?${params.toString()}`
+}
+
+export interface NarrowedIn {
+    wire: string
+    rows: Record<string, unknown>[]
+    missingIds: string[]
+    field: string
+    shape: string
+}
+
+/** Drops ids already cached for this shape. An empty wire means nothing has to travel. */
+export function narrowInToken(token: string, now = Date.now()): NarrowedIn | null {
+    const parsed = splitInToken(token)
+    if (!parsed) return null
+    const scope = cacheScope()
+    const rows: Record<string, unknown>[] = []
+    const missingIds: string[] = []
+    for (const id of parsed.ids) {
+        const hit = entityCache.get(entityKey(scope, parsed.shape, id))
+        if (!hit || now - hit.at >= ENTITY_TTL_MS) {
+            missingIds.push(id)
+            continue
+        }
+        rows.push(...hit.rows)
+    }
+    if (missingIds.length === parsed.ids.length) return null
+    return {
+        wire: missingIds.length === 0 ? '' : replaceInIds(token, parsed.field, missingIds),
+        rows,
+        missingIds,
+        field: parsed.field,
+        shape: parsed.shape,
+    }
+}
+
+/**
+ * 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[],
+    rows: unknown,
+    now = Date.now(),
+): void {
+    const parsed = splitInToken(token)
+    if (!parsed) return
+    const scope = cacheScope()
+    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>)[field] ?? '').trim()
+            const bucket = byId.get(id)
+            if (bucket) bucket.push(row as Record<string, unknown>)
+        }
+    }
+    for (const [id, bucket] of byId) {
+        entityCache.set(entityKey(scope, parsed.shape, id), { rows: bucket, at: now })
+    }
+}
+
+export function resetQueryBatchCache(): void {
+    partCache.clear()
+    entityCache.clear()
+    waiters = []
+    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
 
+function mergeCachedRows(cached: Record<string, unknown>[] | undefined, part: QueryPart): QueryPart {
+    if (!cached?.length) return part
+    const fresh = Array.isArray(part.data) ? part.data : []
+    return { ...part, data: [...cached, ...fresh] }
+}
+
 function cacheScope(): string {
     if (typeof localStorage === 'undefined') return ''
     try {
@@ -80,12 +248,24 @@ 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)
+    if (narrowed && narrowed.wire === '') {
+        return Promise.resolve({ success: true, data: narrowed.rows, meta: { total: narrowed.rows.length } })
+    }
     return new Promise((resolve, reject) => {
         transport = api
-        waiters.push({ token, resolve, reject })
+        waiters.push({
+            token,
+            wire: narrowed?.wire ?? token,
+            resolve,
+            reject,
+            cachedRows: narrowed?.rows,
+            missingIds: narrowed?.missingIds,
+            field: narrowed?.field,
+        })
         if (timer == null) timer = setTimeout(() => void flushQueryBatch(), WINDOW_MS)
     })
 }
@@ -96,13 +276,14 @@ async function flushQueryBatch() {
     waiters = []
     const api = transport
     if (!api || batch.length === 0) return
-    const named = nameBatchTokens(batch.map((waiter) => waiter.token))
+    const named = nameBatchTokens(batch.map((waiter) => waiter.wire))
     const byToken = new Map(named.map((part) => [part.token, part.name]))
     const inm: Record<string, string> = {}
     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 })
@@ -111,7 +292,7 @@ async function flushQueryBatch() {
             throw new Error('batch unavailable')
         }
         for (const waiter of batch) {
-            const name = byToken.get(waiter.token)
+            const name = byToken.get(waiter.wire)
             const part = name ? (body.parts[name] as QueryPart | undefined) : undefined
             if (!part) {
                 waiter.reject(new Error('batch part missing'))
@@ -120,17 +301,103 @@ 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) {
+                rememberInRows(waiter.token, waiter.missingIds, part.data)
             }
             if (part.success) {
-                partCache.set(`${scope}\n${waiter.token}`, { part, at: Date.now() })
+                partCache.set(`${scope}\n${waiter.token}`, { part: merged, at: Date.now() })
             }
-            waiter.resolve(part)
+            waiter.resolve(merged)
         }
     } catch (err) {
         const error = err instanceof Error ? err : new Error(String(err))
         for (const waiter of batch) waiter.reject(error)
     }
 }
+
+function canonicalParams(params?: Record<string, unknown>): string {
+    if (!params) return ''
+    const keys = Object.keys(params)
+        .filter((key) => params[key] != null && params[key] !== '')
+        .sort()
+    const search = new URLSearchParams()
+    for (const key of keys) search.set(key, String(params[key]))
+    return search.toString()
+}
+
+/**
+ * Token for a host GET that the batch can serve. Custom endpoints, aggregates
+ * and `/me` stay on the legacy GET.
+ */
+export function tokenForGet(url: string, params?: Record<string, unknown>): string | null {
+    const [path, query = ''] = url.split('?')
+    const table = path.match(/^\/metadata\/table\/([A-Za-z][A-Za-z0-9_]*)$/)
+    if (table) return `m:${table[1]}`
+    const modal = path.match(/^\/metadata\/modal\/([A-Za-z][A-Za-z0-9_]*)$/)
+    if (modal) return `mm:${modal[1]}`
+    const list = path.match(/^\/data\/([A-Za-z][A-Za-z0-9_]*)$/)
+    if (list) {
+        const q = canonicalParams(params)
+        return q ? `t:${list[1]}?${q}` : `t:${list[1]}`
+    }
+    const opt = path.match(/^\/options\/([A-Za-z][A-Za-z0-9_]*)$/)
+    if (!opt) return null
+    const search = new URLSearchParams(query)
+    if (params) {
+        for (const [key, value] of Object.entries(params)) {
+            if (value != null && value !== '') search.set(key, String(value))
+        }
+    }
+    const limit = Number(search.get('limit'))
+    return optionsBatchToken(
+        opt[1],
+        search.get('field') || 'id',
+        search.get('q') || search.get('search') || '',
+        Number.isFinite(limit) && limit > 0 ? limit : undefined,
+        search.get('filter_value') || undefined,
+    )
+}
+
+function batchForbidden(message?: string): boolean {
+    return /forbidden|permiso/i.test(message || '')
+}
+
+/**
+ * GET through the batch when the URL is a list, table metadata, modal metadata
+ * or options read. Anything the batch refuses falls back to the original GET.
+ */
+export async function batchGet(api: ApiClient, url: string, config?: { params?: Record<string, unknown> }) {
+    const token = tokenForGet(url, config?.params)
+    if (!token) return api.get(url, config)
+    try {
+        const part = await loadQueryPart(api, token)
+        if (!part.success) {
+            if (batchForbidden(part.message)) {
+                const err = new Error(part.message || 'forbidden') as Error & {
+                    status: number
+                    response: { status: number }
+                }
+                err.status = 403
+                err.response = { status: 403 }
+                throw err
+            }
+            return api.get(url, config)
+        }
+        return { data: { success: true, data: part.data, meta: part.meta } }
+    } catch (err) {
+        const status = (err as { status?: number; response?: { status?: number } })?.status
+            ?? (err as { response?: { status?: number } })?.response?.status
+        if (status === 403) throw err
+        return api.get(url, config)
+    }
+}

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',
     },
 }

package/vitest.config.ts

@@ -4,5 +4,6 @@ export default defineConfig({
     test: {
         environment: 'node',
         include: ['src/**/*.test.ts', 'src/**/*.test.tsx'],
+        setupFiles: ['./vitest.setup.ts'],
     },
 })

package/vitest.setup.ts

@@ -0,0 +1,29 @@
+// Node 26 exposes a global localStorage getter that returns undefined unless
+// --localStorage-file is set, and that getter hides happy-dom's storage.
+// Tests that persist page size or the metadata cache need a real Storage.
+
+function installMemoryStorage(name: 'localStorage' | 'sessionStorage') {
+    const current = globalThis[name] as Storage | undefined
+    if (current && typeof current.clear === 'function' && typeof current.setItem === 'function') return
+    const store = new Map<string, string>()
+    const memory: Storage = {
+        getItem: (key) => (store.has(key) ? store.get(key)! : null),
+        setItem: (key, value) => {
+            store.set(String(key), String(value))
+        },
+        removeItem: (key) => {
+            store.delete(String(key))
+        },
+        clear: () => {
+            store.clear()
+        },
+        key: (index) => Array.from(store.keys())[index] ?? null,
+        get length() {
+            return store.size
+        },
+    }
+    Object.defineProperty(globalThis, name, { value: memory, configurable: true, writable: true })
+}
+
+installMemoryStorage('localStorage')
+installMemoryStorage('sessionStorage')