@asteby/metacore-runtime-react 39.2.6 → 39.2.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asteby/metacore-runtime-react",
-  "version": "39.2.6",
+  "version": "39.2.8",
   "description": "React runtime for metacore hosts — renders addon contributions dynamically",
   "repository": {
     "type": "git",

package/src/api-context.tsx

@@ -2,7 +2,8 @@
 // runtime-react components (DynamicTable, dialogs, action dispatcher) can
 // talk to the backend without a bundler alias to `@/lib/api`. Hosts wrap
 // their app in <ApiProvider value={axiosInstance}> once at the root.
-import React, { createContext, useContext } from 'react'
+import React, { createContext, useContext, useMemo } from 'react'
+import { batchGet } from './query-batch'
 
 /** Minimal axios-compatible client shape consumed by runtime-react. */
 export interface ApiClient {
@@ -29,7 +30,14 @@ export function useApi(): ApiClient {
     if (!ctx) {
         throw new Error('useApi() requires an <ApiProvider> ancestor. Hosts must inject an axios-like client via runtime-react ApiProvider.')
     }
-    return ctx
+    // List, metadata and options GETs share one POST /api/q. Mutations stay
+    // on the host client. The wrapper is stable while the host client is.
+    return useMemo<ApiClient>(() => ({
+        get: (url, config) => batchGet(ctx, url, config),
+        post: (url, body, config) => ctx.post(url, body, config),
+        put: (url, body, config) => ctx.put(url, body, config),
+        delete: (url, config) => ctx.delete(url, config),
+    }), [ctx])
 }
 
 /** Optional branch context — hosts that support tenant branches can supply

package/src/dynamic-table.tsx

@@ -78,6 +78,7 @@ import {
 import { OptionsContext } from './options-context'
 import type { TableMetadata, ApiResponse, ColumnDefinition } from './types'
 import { getSearchableColumnKeys } from './column-visibility'
+import { visibleRelationInclude } from './list-include'
 import { useDebouncedValue } from './use-debounced-value'
 import { useCan, usePermissionsActive, gateTableMetadata } from './permissions-context'
 import { useDynamicRowActions } from './dynamic-row-actions'
@@ -808,6 +809,11 @@ export function DynamicTable({
         return Array.from(set)
     }, [hiddenColumns, scopeHiddenColumns])
 
+    const relationInclude = useMemo(
+        () => visibleRelationInclude(metadata?.columns, effectiveHiddenColumns),
+        [metadata, effectiveHiddenColumns],
+    )
+
     const buildFilterParams = useCallback(() => {
         const params: Record<string, any> = {}
         if (sorting.length > 0) {
@@ -868,6 +874,7 @@ export function DynamicTable({
                 per_page: pagination.pageSize,
                 ...buildFilterParams(),
             }
+            if (relationInclude) params.include = relationInclude
             const res = await api.get(endpoint || `/data/${model}`, { params }) as { data: ApiResponse<any[]> }
             setForbidden(false)
             if (res.data.success) {
@@ -895,7 +902,7 @@ export function DynamicTable({
         } finally {
             setLoadingData(false)
         }
-    }, [model, metadata, pagination, buildFilterParams, refreshTrigger, endpoint, currentBranch?.id, api, enableUrlSync])
+    }, [model, metadata, pagination, buildFilterParams, refreshTrigger, endpoint, currentBranch?.id, api, enableUrlSync, relationInclude])
 
     // Columns whose metadata opts into a footer total (display_config.aggregate
     // → styleConfig.aggregate). When empty, no footer row is rendered and no
@@ -936,6 +943,7 @@ export function DynamicTable({
                     per_page: infPageSize,
                     ...buildFilterParams(),
                 }
+                if (relationInclude) params.include = relationInclude
                 const res = (await api.get(endpoint || `/data/${model}`, {
                     params,
                 })) as { data: ApiResponse<any[]> }
@@ -974,7 +982,7 @@ export function DynamicTable({
                 else setLoadingData(false)
             }
         },
-        [metadata, buildFilterParams, endpoint, model, api, currentBranch?.id, enableUrlSync],
+        [metadata, buildFilterParams, endpoint, model, api, currentBranch?.id, enableUrlSync, relationInclude],
     )
 
     // Signature of everything that must reset the incremental list to page 1:

package/src/index.ts

@@ -392,6 +392,21 @@ export {
     AUDIT_SUBTABLE_COLUMN_KEYS,
     getSearchableColumnKeys,
 } from './column-visibility'
+export {
+    batchGet,
+    loadQueryPart,
+    nameBatchTokens,
+    narrowInToken,
+    optionsBatchToken,
+    optionsModelFromUrl,
+    rememberInRows,
+    resetQueryBatchCache,
+    splitInToken,
+    tokenForGet,
+    type InListToken,
+    type NarrowedIn,
+    type QueryPart,
+} from './query-batch'
 export {
     useOptionsResolver,
     projectOption,

package/src/list-include.test.ts

@@ -0,0 +1,33 @@
+import { describe, expect, it } from 'vitest'
+import { visibleRelationInclude } from './list-include'
+import type { ColumnDefinition } from './types'
+
+function col(partial: Partial<ColumnDefinition> & { key: string }): ColumnDefinition {
+    return { label: partial.key, type: 'text', sortable: false, filterable: false, ...partial }
+}
+
+describe('visibleRelationInclude', () => {
+    it('omits the parameter when the table has no relations', () => {
+        expect(visibleRelationInclude([col({ key: 'name' })])).toBeUndefined()
+        expect(visibleRelationInclude(undefined)).toBeUndefined()
+    })
+
+    it('lists only the visible relation columns', () => {
+        const include = visibleRelationInclude([
+            col({ key: 'name' }),
+            col({ key: 'customer_id', type: 'relation' }),
+            col({ key: 'warehouse_id', ref: 'inventory.Warehouse', hidden: true }),
+            col({ key: 'created_by', type: 'creator' }),
+            col({ key: 'items', item_fields: [{ key: 'product_id', label: 'Producto' }] }),
+        ])
+        expect(include).toBe('customer_id,created_by,items')
+    })
+
+    it('drops a column the view hid', () => {
+        const include = visibleRelationInclude(
+            [col({ key: 'customer_id', type: 'relation' }), col({ key: 'user_id', type: 'user' })],
+            ['user_id'],
+        )
+        expect(include).toBe('customer_id')
+    })
+})

package/src/list-include.ts

@@ -0,0 +1,34 @@
+import type { ColumnDefinition } from './types'
+
+/**
+ * Columns whose labels come from a relation lookup. The list asks the server
+ * to resolve only these, so hidden foreign keys do not each become a query.
+ * Returns undefined when nothing relational is visible: the server then keeps
+ * resolving everything, which is what hosts do before they send `include=`.
+ */
+export function visibleRelationInclude(
+    columns: ColumnDefinition[] | undefined,
+    hidden: string[] = [],
+): string | undefined {
+    if (!columns?.length) return undefined
+    const hide = new Set(hidden)
+    const keys: string[] = []
+    for (const col of columns) {
+        if (!col?.key || col.hidden || hide.has(col.key)) continue
+        if (col.visibility === 'modal' || col.visibility === 'list') continue
+        if (!columnNeedsRelation(col)) continue
+        keys.push(col.key)
+    }
+    if (keys.length === 0) return undefined
+    return keys.join(',')
+}
+
+function columnNeedsRelation(col: ColumnDefinition): boolean {
+    if (col.type === 'relation' || col.type === 'relation-badge-list' || col.type === 'creator' || col.type === 'user') {
+        return true
+    }
+    if (col.cellStyle === 'relation' || col.cellStyle === 'reference') return true
+    if (col.ref) return true
+    if (col.itemFields?.length || col.item_fields?.length) return true
+    return false
+}

package/src/query-batch.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from 'vitest'
+import {
+    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', () => {
+        const named = nameBatchTokens([
+            'o:Customer?field=id',
+            'o:Product?field=id',
+            'o:Customer?field=id',
+        ])
+        expect(named).toEqual([
+            { name: 'q1', token: 'o:Customer?field=id', plan: 'q1=o:Customer?field=id' },
+            { name: 'q2', token: 'o:Product?field=id', plan: 'q2=o:Product?field=id' },
+        ])
+    })
+
+    it('builds an options token from the canonical url', () => {
+        expect(optionsModelFromUrl('/options/Customer')).toBe('Customer')
+        expect(optionsModelFromUrl('/data/Customer')).toBeNull()
+        expect(optionsBatchToken('Customer', 'id', 'lop', 20, undefined)).toBe(
+            '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')
+    })
+})

package/src/query-batch.ts

@@ -0,0 +1,354 @@
+/**
+ * Coalesces concurrent reads into one POST /api/q.
+ *
+ * Callers enqueue a batch token (`o:Customer?field=id&q=lop`). Tokens that
+ * arrive inside an 8ms window share one request. Each part keeps its own
+ * success, data and etag. A failed part does not reject the others.
+ */
+import type { ApiClient } from './api-context'
+
+export interface QueryPart {
+    success: boolean
+    data?: unknown
+    meta?: unknown
+    message?: string
+    etag?: string
+    not_modified?: boolean
+}
+
+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 = { row: Record<string, unknown> | null; at: number }
+
+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. */
+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))
+    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}`
+}
+
+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
+        }
+        if (hit.row) rows.push(hit.row)
+    }
+    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 one row per requested id. 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 seen = new Set<string>()
+    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,
+            })
+        }
+    }
+    for (const id of ids) {
+        if (seen.has(id)) continue
+        entityCache.set(entityKey(scope, parsed.shape, id), { row: null, at: now })
+    }
+}
+
+export function resetQueryBatchCache(): void {
+    partCache.clear()
+    entityCache.clear()
+    waiters = []
+    if (timer != null) clearTimeout(timer)
+    timer = null
+}
+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 {
+        const raw = localStorage.getItem('auth_user')
+        if (!raw) return ''
+        return String((JSON.parse(raw) as { organization_id?: string }).organization_id ?? '')
+    } catch {
+        return ''
+    }
+}
+
+export function optionsModelFromUrl(url: string): string | null {
+    const match = url.match(/^\/options\/([A-Za-z][A-Za-z0-9_]*)$/)
+    return match ? match[1] : null
+}
+
+export function optionsBatchToken(
+    model: string,
+    field: string,
+    query: string,
+    limit: number | undefined,
+    filter: string | undefined,
+): string {
+    const params = new URLSearchParams()
+    params.set('field', field)
+    if (query) params.set('q', query)
+    if (typeof limit === 'number' && limit > 0) params.set('limit', String(limit))
+    if (filter) params.set('filter_value', filter)
+    return `o:${model}?${params.toString()}`
+}
+
+/** Names each distinct token so the server can key the response. */
+export function nameBatchTokens(tokens: string[]): { name: string; token: string; plan: string }[] {
+    const unique: string[] = []
+    const seen = new Set<string>()
+    for (const token of tokens) {
+        if (seen.has(token)) continue
+        seen.add(token)
+        unique.push(token)
+    }
+    return unique.map((token, index) => {
+        const name = `q${index + 1}`
+        return { name, token, plan: `${name}=${token}` }
+    })
+}
+
+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) {
+        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,
+            wire: narrowed?.wire ?? token,
+            resolve,
+            reject,
+            cachedRows: narrowed?.rows,
+            missingIds: narrowed?.missingIds,
+            field: narrowed?.field,
+        })
+        if (timer == null) timer = setTimeout(() => void flushQueryBatch(), WINDOW_MS)
+    })
+}
+
+async function flushQueryBatch() {
+    timer = null
+    const batch = waiters
+    waiters = []
+    const api = transport
+    if (!api || batch.length === 0) return
+    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
+    }
+    try {
+        const res = await api.post('/q', { parts: named.map((part) => part.plan), inm })
+        const body = res?.data
+        if (!body || body.success !== true || !body.parts) {
+            throw new Error('batch unavailable')
+        }
+        for (const waiter of batch) {
+            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'))
+                continue
+            }
+            if (part.not_modified) {
+                const cached = partCache.get(`${scope}\n${waiter.token}`)
+                if (cached) {
+                    waiter.resolve(cached.part)
+                    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: merged, at: Date.now() })
+            }
+            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

@@ -12,6 +12,7 @@
 // free; legacy callers that still ship `searchEndpoint` keep working.
 import { useEffect, useMemo, useRef, useState } from 'react'
 import { useApi } from './api-context'
+import { loadQueryPart, optionsBatchToken, optionsModelFromUrl } from './query-batch'
 
 export interface ResolvedOption {
     /** Canonical id (server-side primary key). */
@@ -237,7 +238,33 @@ export function useOptionsResolver(args: UseOptionsResolverArgs): UseOptionsReso
             if (query) params.q = query
             if (typeof limit === 'number' && limit > 0) params.limit = limit
             if (filterValue) params.filter_value = filterValue
-            pending = api.get(url, { params }).then((res) => {
+            const model = optionsModelFromUrl(url)
+            pending = (async () => {
+                if (model) {
+                    try {
+                        const part = await loadQueryPart(
+                            api,
+                            optionsBatchToken(model, effectiveField, query ?? '', limit, filterValue),
+                        )
+                        if (!part.success) {
+                            throw new Error(part.message || 'options resolver: unsuccessful response')
+                        }
+                        const payload = readOptionsEnvelope({
+                            success: true,
+                            data: part.data,
+                            meta: part.meta,
+                        })
+                        if ((optionsEpoch.get(key) ?? 0) === epoch) {
+                            optionsCache.set(key, { payload, at: Date.now() })
+                        }
+                        return payload
+                    } catch (err) {
+                        const msg = err instanceof Error ? err.message : ''
+                        const batchMiss = msg === 'batch unavailable' || msg === 'batch part missing'
+                        if (!batchMiss) throw err
+                    }
+                }
+                const res = await api.get(url, { params })
                 const body = (res as { data: any }).data
                 if (!body || body.success !== true) {
                     throw new Error(body?.message || 'options resolver: unsuccessful response')
@@ -247,7 +274,7 @@ export function useOptionsResolver(args: UseOptionsResolverArgs): UseOptionsReso
                     optionsCache.set(key, { payload, at: Date.now() })
                 }
                 return payload
-            }).finally(() => {
+            })().finally(() => {
                 if (optionsInflight.get(key) === pending) optionsInflight.delete(key)
             })
             optionsInflight.set(key, pending)

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