@quazardous/qdadm 1.22.0 → 2.1.0

package/README.md

@@ -31,7 +31,7 @@ import { SecurityChecker, PermissionMatcher, PermissionRegistry } from '@quazard
 import { PersistableRoleProvider, createLocalStorageRolesProvider } from '@quazardous/qdadm/security'
 
 // Composables
-import { useForm, useBareForm, useListPage } from '@quazardous/qdadm/composables'
+import { useBareForm, useListPage } from '@quazardous/qdadm/composables'
 
 // Components
 import { ListPage, PageLayout, AppLayout, FormField, FormActions } from '@quazardous/qdadm/components'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quazardous/qdadm",
-  "version": "1.22.0",
+  "version": "2.1.0",
   "description": "Vue 3 framework for admin dashboards with PrimeVue",
   "author": "quazardous",
   "license": "MIT",

package/src/api/apiClient.ts

@@ -0,0 +1,34 @@
+/**
+ * Kernel-level default API client (qdadm #1198)
+ *
+ * Apps already build an axios-compatible HttpClient (base URL + auth
+ * interceptors) for their ApiStorages. Registering it once on the kernel
+ * makes it available to composables/widgets that need ad-hoc API calls
+ * (useOptionsLookup endpoint mode, ScopeEditor), so relative endpoints
+ * get base URL + auth applied without per-call wiring:
+ *
+ *   new Kernel({ apiClient: myAxios })
+ */
+import { inject } from 'vue'
+import type { HttpClient } from '../entity/storage/ApiStorage'
+
+/** Injection key under which the kernel provides the default API client. */
+export const API_CLIENT_INJECTION_KEY = 'qdadmApiClient'
+
+/** Accepted forms of the kernel `apiClient` option. */
+export type ApiClientSource = HttpClient | (() => HttpClient)
+
+/** Resolve an ApiClientSource (direct instance or factory) to a client. */
+export function resolveApiClient(source: ApiClientSource | null | undefined): HttpClient | null {
+  if (!source) return null
+  return typeof source === 'function' ? source() : source
+}
+
+/**
+ * Inject the kernel-registered default API client, or null when none is
+ * registered. Must be called from a setup context (like any inject).
+ */
+export function useApiClient(): HttpClient | null {
+  const source = inject<ApiClientSource | null>(API_CLIENT_INJECTION_KEY, null)
+  return resolveApiClient(source)
+}

package/src/components/editors/ScopeEditor.vue

@@ -1,5 +1,6 @@
 <script setup lang="ts">
 import { ref, computed, onMounted, watch, inject } from 'vue'
+import type { HttpClient } from '../../entity/storage/ApiStorage'
 import AutoComplete from 'primevue/autocomplete'
 import Select from 'primevue/select'
 import Button from 'primevue/button'
@@ -43,8 +44,10 @@ const props = withDefaults(defineProps<Props>(), {
   defaultActions: null
 })
 
-// Get API adapter (optional)
+// Get API adapter (optional); the kernel default client (Kernel({ apiClient }))
+// serves as fallback so scope endpoints get base URL + auth without app wiring.
 const api = inject<ApiAdapter | null>('apiAdapter', null)
+const kernelApiClient = inject<HttpClient | (() => HttpClient) | null>('qdadmApiClient', null)
 
 // Get global scope config (optional) - allows app-level configuration
 const globalScopeConfig = inject<ScopeConfig>('scopeConfig', {})
@@ -178,8 +181,17 @@ function isRowComplete(row: ScopeRow): boolean {
 async function loadScopeDefinition(): Promise<void> {
   loading.value = true
   try {
-    if (!api) {
-      // No API adapter, use defaults
+    let data: ScopeDefinition | null = null
+    if (api) {
+      data = await api.request('GET', config.value.endpoint)
+    } else if (kernelApiClient) {
+      // Fallback: kernel default API client (base URL + auth applied)
+      const client = typeof kernelApiClient === 'function' ? kernelApiClient() : kernelApiClient
+      data = (await client.get<ScopeDefinition>(config.value.endpoint)).data
+    }
+
+    if (!data) {
+      // No API layer available, use defaults
       scopeDefinition.value = {
         resources: [...config.value.resources],
         actions: [...config.value.actions],
@@ -187,7 +199,6 @@ async function loadScopeDefinition(): Promise<void> {
       return
     }
 
-    const data = await api.request('GET', config.value.endpoint)
     scopeDefinition.value = {
       resources: data.resources || [...config.value.resources],
       actions: data.actions || [...config.value.actions],

package/src/components/index.ts

@@ -27,8 +27,6 @@ export { default as FormPage } from './edit/FormPage.vue'
 export { default as FormField } from './edit/FormField.vue'
 export { default as FormInput } from './edit/FormInput.vue'
 export { default as FormActions } from './edit/FormActions.vue'
-export { default as FormTabs } from './edit/FormTabs.vue' // Deprecated: use FieldGroups with layout="tabs"
-export { default as FormTab } from './edit/FormTab.vue' // Deprecated: use FieldGroups with layout="tabs"
 export { default as LookupField } from './edit/LookupField.vue'
 export { default as LookupPickerDialog } from './edit/LookupPickerDialog.vue'
 
@@ -41,7 +39,6 @@ export { default as ParentCard } from './show/ParentCard.vue'
 // Lists
 export { default as ListPage } from './lists/ListPage.vue'
 export { default as ActionButtons } from './lists/ActionButtons.vue'
-export { default as ActionColumn } from './lists/ActionColumn.vue'
 export { default as FilterBar } from './lists/FilterBar.vue'
 
 // Editors (vanilla-jsoneditor free)

package/src/components/layout/AppLayout.vue

@@ -50,7 +50,7 @@ interface UserData {
 const features = inject<FeaturesConfig>('qdadmFeatures', { poweredBy: true, breadcrumb: true })
 const homeRoute = inject<string>('qdadmHomeRoute', 'home')
 
-// Guard dialog from shared store (registered by useBareForm/useForm when a form is active)
+// Guard dialog from shared store (registered by useBareForm/useEntityItemFormPage when a form is active)
 const guardDialog = useGuardDialog()
 
 const router = useRouter()
@@ -238,7 +238,7 @@ watch(() => route.fullPath, () => {
 })
 
 // Navigation context (breadcrumb + navlinks from route config)
-// Entity data comes from activeStack (populated by useEntityItemPage/useForm)
+// Entity data comes from activeStack (populated by useEntityItemPage/useEntityItemFormPage)
 const { breadcrumb: defaultBreadcrumb, navlinks: defaultNavlinks } = useNavContext()
 
 // Allow child pages to override breadcrumb/navlinks via provide/inject

package/src/components/layout/BaseLayout.vue

@@ -50,7 +50,7 @@ import DefaultBreadcrumb from './defaults/DefaultBreadcrumb.vue'
 const slots = useSlots()
 const hasMainSlot: boolean = !!slots.main
 
-// Guard dialog from shared store (registered by useBareForm/useForm when a form is active)
+// Guard dialog from shared store (registered by useBareForm/useEntityItemFormPage when a form is active)
 const guardDialog = useGuardDialog()
 
 // Provide breadcrumb/navlinks override mechanism for child pages

package/src/components/layout/PageHeader.vue

@@ -47,7 +47,7 @@ const props = withDefaults(defineProps<Props>(), {
   badges: () => []
 })
 
-// Auto-injected title from useForm (if available)
+// Auto-injected title from the form composables (if available)
 const injectedTitleParts = inject<Ref<TitleParts | null> | null>('qdadmPageTitleParts', null)
 
 // Use props first, then injected, then fallback

package/src/components/show/ShowDisplay.vue

@@ -28,6 +28,7 @@
 import { computed, type PropType } from 'vue'
 import { RouterLink, type RouteLocationRaw } from 'vue-router'
 import Tag from 'primevue/tag'
+import { formatDate, formatNumber, formatCurrency } from '../../utils/formatters'
 
 type DisplayType =
   | 'text'
@@ -101,13 +102,12 @@ const textValue = computed(() => {
   return String(props.value)
 })
 
-// Format number value
+// Format number value (browser locale by default — utils/formatters policy)
 const numberValue = computed(() => {
   if (isEmpty.value) return '-'
   const num = Number(props.value)
   if (isNaN(num)) return String(props.value)
-  const locale = props.field.locale || 'en-US'
-  return new Intl.NumberFormat(locale).format(num)
+  return formatNumber(num, {}, props.field.locale)
 })
 
 // Format currency value
@@ -115,9 +115,7 @@ const currencyValue = computed(() => {
   if (isEmpty.value) return '-'
   const num = Number(props.value)
   if (isNaN(num)) return String(props.value)
-  const locale = props.field.locale || 'en-US'
-  const currency = props.field.currencyCode || 'USD'
-  return new Intl.NumberFormat(locale, { style: 'currency', currency }).format(num)
+  return formatCurrency(num, props.field.currencyCode || 'USD', props.field.locale)
 })
 
 // Format boolean value
@@ -143,9 +141,8 @@ const dateValue = computed(() => {
   const v = props.value as unknown
   const date = (typeof v === 'object' && v instanceof Date) ? v : new Date(String(v))
   if (isNaN(date.getTime())) return String(props.value)
-  const locale = props.field.locale || 'en-US'
   const format = props.field.dateFormat || 'short'
-  return new Intl.DateTimeFormat(locale, { dateStyle: format as 'short' | 'medium' | 'long' | 'full' }).format(date)
+  return formatDate(date, { dateStyle: format as 'short' | 'medium' | 'long' | 'full' }, props.field.locale)
 })
 
 // Format datetime value
@@ -154,8 +151,7 @@ const datetimeValue = computed(() => {
   const v = props.value as unknown
   const date = (typeof v === 'object' && v instanceof Date) ? v : new Date(String(v))
   if (isNaN(date.getTime())) return String(props.value)
-  const locale = props.field.locale || 'en-US'
-  return new Intl.DateTimeFormat(locale, { dateStyle: 'short', timeStyle: 'short' }).format(date)
+  return formatDate(date, { dateStyle: 'short', timeStyle: 'short' }, props.field.locale)
 })
 
 // Format select value (lookup label from options)

package/src/composables/index.ts

@@ -15,12 +15,6 @@ export {
   type SemanticBreadcrumbItem,
 } from './useSemanticBreadcrumb'
 export { useDirtyState, type UseDirtyStateReturn } from './useDirtyState'
-export {
-  useForm,
-  type UseFormOptions,
-  type UseFormReturn,
-  type FormAlterConfig,
-} from './useForm'
 export {
   useEntityItemFormPage,
   useEntityItemFormPage as useFormPageBuilder,
@@ -132,7 +126,6 @@ export {
   type UseUserImpersonatorReturn,
   type UserRecord,
 } from './useUserImpersonator'
-export { useCurrentEntity, type UseCurrentEntityReturn } from './useCurrentEntity'
 export {
   useOptionsLookup,
   type UseOptionsLookupConfig,

package/src/composables/useListPage.ts

@@ -35,6 +35,7 @@ import { useEntityItemPage, type ParentConfig, type UseEntityItemPageReturn } fr
 import { useActiveStack } from '../chain/useActiveStack.js'
 import { FilterQuery } from '../query/FilterQuery'
 import { useI18n } from '../i18n/useI18n'
+import { formatDateOnly } from '../utils/formatters'
 
 // Import types from dedicated types file
 import type {
@@ -1307,18 +1308,12 @@ export function useListPage<T = unknown>(config: UseListPageOptions<T>): UseList
   })
 
   // ============ UTILITIES ============
+  // Browser-locale by default (unified policy — see utils/formatters).
   function formatDate(
     dateStr: string | null | undefined,
     options: Intl.DateTimeFormatOptions = {}
   ): string {
-    if (!dateStr) return '-'
-    const defaultOptions: Intl.DateTimeFormatOptions = {
-      day: '2-digit',
-      month: '2-digit',
-      year: 'numeric',
-      ...options,
-    }
-    return new Date(dateStr).toLocaleDateString('fr-FR', defaultOptions)
+    return formatDateOnly(dateStr, options)
   }
 
   // ============ STANDARD ACTIONS ============

package/src/composables/useNavContext.ts

@@ -2,7 +2,7 @@
  * useNavContext - Route-aware navigation context for breadcrumb and navlinks
  *
  * Uses semantic breadcrumb as the source of truth for navigation structure.
- * Entity data comes from activeStack (set by useEntityItemPage/useForm).
+ * Entity data comes from activeStack (set by useEntityItemPage/useEntityItemFormPage).
  *
  * Semantic breadcrumb kinds:
  *   - entity-list: Entity collection (e.g., /books)

package/src/composables/useOptionsLookup.ts

@@ -42,6 +42,7 @@
  */
 import { ref, onMounted, type Ref } from 'vue'
 import { useOrchestrator } from '../orchestrator/useOrchestrator.js'
+import { useApiClient } from '../api/apiClient'
 
 export interface OptionsLookupItem {
   label: string
@@ -66,11 +67,27 @@ export interface UseOptionsLookupConfig {
   entity?: string
   /** Extract distinct values from a specific field (entity mode only) */
   field?: string
-  /** Fetch options from a raw API endpoint */
+  /**
+   * Fetch options from an API endpoint.
+   *
+   * Routing (#1198): a **relative** endpoint goes through the kernel's
+   * default API client when one is registered (`Kernel({ apiClient })`) —
+   * base URL + auth applied, no per-call wiring. An **absolute** URL is
+   * fetched raw (escape hatch for third-party APIs, combine with `headers`).
+   * A relative endpoint with no registered client falls back to a raw fetch
+   * (legacy) with a console warning.
+   */
   endpoint?: string
+  /**
+   * Route the endpoint request through the named entity's storage
+   * (`storage.request('GET', endpoint)`) instead of the kernel client —
+   * explicit refinement for multi-API apps. Takes precedence over the
+   * kernel client.
+   */
+  via?: string
   /** When using endpoint: pick a sub-key from the response data */
   pick?: string
-  /** Extra headers for endpoint fetch (e.g. Authorization) */
+  /** Extra headers for the raw-fetch paths (e.g. Authorization) */
   headers?: Record<string, string> | (() => Record<string, string>)
   /** Static options (no fetch needed) */
   static?: unknown[]
@@ -164,10 +181,16 @@ export function useOptionsLookup(config: UseOptionsLookupConfig): UseOptionsLook
       : defaultDecode
   )
 
-  // Resolve orchestrator lazily (only if entity mode)
-  let getManager: ((name: string) => { list: (params?: Record<string, unknown>) => Promise<{ items: unknown[] }> }) | null = null
+  // Resolve orchestrator lazily (entity mode, or via:'entityName' routing)
+  type LookupManager = {
+    list: (params?: Record<string, unknown>) => Promise<{ items: unknown[] }>
+    storage?: {
+      request?: (method: string, path: string, options?: Record<string, unknown>) => Promise<unknown>
+    }
+  }
+  let getManager: ((name: string) => LookupManager) | null = null
 
-  if (config.entity) {
+  if (config.entity || config.via) {
     try {
       const orc = useOrchestrator()
       // Generic-vs-non-generic: getManager is parameterised by an
@@ -180,6 +203,105 @@ export function useOptionsLookup(config: UseOptionsLookupConfig): UseOptionsLook
     }
   }
 
+  // Kernel default API client (Kernel({ apiClient })) — used for relative
+  // endpoints so base URL + auth apply without per-call wiring (#1198).
+  let apiClient: ReturnType<typeof useApiClient> = null
+  if (config.endpoint) {
+    try {
+      apiClient = useApiClient()
+    } catch {
+      // Outside a setup/injection context
+    }
+  }
+
+  // Bare-relative warning: once per composable instance, not per load
+  let warnedBareRelative = false
+
+  function warnLookup(msg: string): void {
+    console.warn(`[qdadm] useOptionsLookup(endpoint: '${config.endpoint}'): ${msg}`)
+  }
+
+  /** Shared normalization for every endpoint path: unwrap data, pick, array-check. */
+  function normalizeEndpointPayload(json: unknown): unknown[] {
+    let data: unknown = (json as { data?: unknown })?.data ?? json
+    if (config.pick && typeof data === 'object' && data !== null && !Array.isArray(data)) {
+      data = (data as Record<string, unknown>)[config.pick]
+    }
+    if (!Array.isArray(data)) {
+      warnLookup('response contained no usable array (after data/pick unwrap) — check the endpoint payload shape')
+      return []
+    }
+    return data
+  }
+
+  /** Endpoint routing (#1198): via storage > relative→kernel client > raw fetch. */
+  async function loadFromEndpoint(): Promise<unknown[]> {
+    const endpoint = config.endpoint!
+    const isAbsolute = /^https?:\/\//i.test(endpoint)
+
+    // 1. via:'entityName' → that entity's storage (explicit refinement)
+    if (config.via && getManager) {
+      const storage = getManager(config.via)?.storage
+      if (storage?.request) {
+        try {
+          const json = await storage.request('GET', endpoint)
+          return normalizeEndpointPayload(json)
+        } catch (err) {
+          warnLookup(`request via '${config.via}' storage failed: ${err instanceof Error ? err.message : err}`)
+          throw err
+        }
+      }
+      warnLookup(`via: '${config.via}' has no storage.request() — falling back to the default routing`)
+    }
+
+    // 2. relative endpoint → kernel default API client (base URL + auth)
+    if (!isAbsolute && apiClient) {
+      try {
+        const { data } = await apiClient.get(endpoint)
+        return normalizeEndpointPayload(data)
+      } catch (err) {
+        warnLookup(`request through the kernel apiClient failed: ${err instanceof Error ? err.message : err}`)
+        throw err
+      }
+    }
+
+    // 3. raw fetch — absolute URL (escape hatch) or legacy relative call
+    if (!isAbsolute && !warnedBareRelative) {
+      warnedBareRelative = true
+      warnLookup(
+        'relative endpoint fetched bare — no API base URL or auth header applied. ' +
+        'Register Kernel({ apiClient }) (recommended), use via: \'entityName\', or pass an absolute URL + headers.'
+      )
+    }
+    const extraHeaders = typeof config.headers === 'function' ? config.headers() : config.headers
+    const response = await fetch(endpoint, {
+      credentials: 'include',
+      headers: { 'Accept': 'application/json', ...extraHeaders },
+    })
+    if (!response.ok) {
+      const authHint = response.status === 401 || response.status === 403
+        ? ' — missing auth? register Kernel({ apiClient }) or pass headers'
+        : ''
+      warnLookup(`HTTP ${response.status}${authHint}`)
+      throw new Error(`HTTP ${response.status}`)
+    }
+    const contentType = response.headers.get('content-type') || ''
+    if (!contentType.includes('json')) {
+      warnLookup(
+        `response is not JSON (content-type: '${contentType || 'unknown'}') — the relative URL likely resolved ` +
+        'to the app origin (HTML page). Register Kernel({ apiClient }) or use an absolute URL.'
+      )
+    }
+    let json: unknown
+    try {
+      json = await response.json()
+    } catch (err) {
+      warnLookup(`response body is not parseable JSON: ${err instanceof Error ? err.message : err}`)
+      throw err
+    }
+    return normalizeEndpointPayload(json)
+  }
+
   // Encoded strings cache for mapped mode (rebuilt on processItems)
   let encodedStrings: string[] = []
 
@@ -255,21 +377,7 @@ export function useOptionsLookup(config: UseOptionsLookupConfig): UseOptionsLook
           items = rawItems
         }
       } else if (config.endpoint) {
-        const extraHeaders = typeof config.headers === 'function' ? config.headers() : config.headers
-        const response = await fetch(config.endpoint, {
-          credentials: 'include',
-          headers: { 'Accept': 'application/json', ...extraHeaders },
-        })
-        if (!response.ok) throw new Error(`HTTP ${response.status}`)
-        const json = await response.json()
-
-        let data = json.data ?? json
-
-        if (config.pick && typeof data === 'object' && !Array.isArray(data)) {
-          data = (data as Record<string, unknown>)[config.pick]
-        }
-
-        items = Array.isArray(data) ? data : []
+        items = await loadFromEndpoint()
       }
 
       processItems(items)

package/src/composables/usePageTitle.ts

@@ -2,7 +2,7 @@
  * usePageTitle - Provide custom page title for PageHeader
  *
  * Use this composable in custom pages to set the title displayed in PageHeader.
- * For standard CRUD pages, useForm handles this automatically.
+ * For standard CRUD pages, useEntityItemFormPage handles this automatically.
  *
  * Usage:
  * ```ts
@@ -77,7 +77,7 @@ export function usePageTitle(
     }
   }
 
-  // Provide to PageHeader via same key as useForm
+  // Provide to PageHeader via same key as the form composables
   provide('qdadmPageTitleParts', titleParts)
 
   return { titleParts, setTitle }

package/src/entity/EntityManager.crud.ts

@@ -137,7 +137,7 @@ export function applyCrudMethods(EntityManagerClass: { prototype: any }): void {
       const apiResponse = (await storage.request('GET', endpoint, {
         params: requestParams,
         context,
-      })) as { data?: unknown }
+      })) as { data?: unknown; total?: number; pagination?: { total?: number } }
       // Normalize response
       const data = apiResponse.data ?? apiResponse
       const dataObj = data as {
@@ -150,9 +150,14 @@ export function applyCrudMethods(EntityManagerClass: { prototype: any }): void {
         items: Array.isArray(data)
           ? (data as any[])
           : dataObj.items || dataObj.data || [],
+        // Wrapper shapes like { data: [...], pagination: { total } } or
+        // { data: [...], total } carry the total on apiResponse, not on the
+        // unwrapped array — read both levels before falling back to page length.
         total:
           dataObj.total ??
           dataObj.pagination?.total ??
+          apiResponse.total ??
+          apiResponse.pagination?.total ??
           (Array.isArray(data) ? (data as any[]).length : 0),
       }
     } else {

package/src/entity/storage/ApiStorage.ts

@@ -57,11 +57,6 @@ export class ApiStorage<T extends EntityRecord = EntityRecord> extends IStorage<
     supportsCaching: true,
   }
 
-  /** @deprecated Use static ApiStorage.capabilities.supportsCaching instead */
-  get supportsCaching(): boolean {
-    return ApiStorage.capabilities.supportsCaching
-  }
-
   readonly endpoint: string
   readonly responseItemsKey: string
   readonly responseTotalKey: string

package/src/entity/storage/LocalStorage.ts

@@ -27,11 +27,6 @@ export class LocalStorage<T extends EntityRecord = EntityRecord> extends IStorag
     supportsCaching: false,
   }
 
-  /** @deprecated Use static LocalStorage.capabilities.supportsCaching instead */
-  get supportsCaching(): boolean {
-    return LocalStorage.capabilities.supportsCaching
-  }
-
   readonly key: string
   readonly idField: string
   readonly generateId: () => string

package/src/entity/storage/MemoryStorage.ts

@@ -38,11 +38,6 @@ export class MemoryStorage<T extends EntityRecord = EntityRecord> extends IStora
     supportsCaching: false,
   }
 
-  /** @deprecated Use static MemoryStorage.capabilities.supportsCaching instead */
-  get supportsCaching(): boolean {
-    return MemoryStorage.capabilities.supportsCaching
-  }
-
   readonly idField: string
   readonly generateId: () => string
   protected _data: Map<string, T>

package/src/entity/storage/MockApiStorage.ts

@@ -35,11 +35,6 @@ export class MockApiStorage<T extends EntityRecord = EntityRecord> extends IStor
     supportsCaching: false,
   }
 
-  /** @deprecated Use static MockApiStorage.capabilities.supportsCaching instead */
-  get supportsCaching(): boolean {
-    return MockApiStorage.capabilities.supportsCaching
-  }
-
   /**
    * Instance capabilities getter.
    * Merges static capabilities with instance-specific ones like requiresAuth.

package/src/entity/storage/SdkStorage.ts

@@ -91,11 +91,6 @@ export class SdkStorage<T extends EntityRecord = EntityRecord> extends IStorage<
     supportsCaching: true,
   }
 
-  /** @deprecated Use SdkStorage.capabilities.supportsCaching instead */
-  get supportsCaching(): boolean {
-    return SdkStorage.capabilities.supportsCaching
-  }
-
   readonly clientSidePagination: boolean
 
   protected _sdk: SdkInstance | null

package/src/generated/managers/testManager.ts

@@ -0,0 +1,46 @@
+/**
+ * TestManager - Auto-generated EntityManager
+ *
+ * Generated by qdadm/gen/generateManagers
+ * DO NOT EDIT MANUALLY - Changes will be overwritten
+ *
+ * Entity: test
+ * Endpoint: /test
+ */
+
+import { EntityManager } from '@quazardous/qdadm'
+import type { EntityRecord } from '@quazardous/qdadm'
+import { ApiStorage } from '@quazardous/qdadm'
+
+export interface TestEntity extends EntityRecord {
+}
+
+/**
+ * Schema definition for test
+ */
+export const testSchema = {
+  name: "test",
+  endpoint: "/test",
+  fields: {}
+} as const
+
+/**
+ * Storage options for test
+ */
+const storageOptions = {
+  endpoint: "/test"
+}
+
+/**
+ * TestManager instance
+ *
+ * Provides CRUD operations for test entity.
+ */
+export const testManager = new EntityManager<TestEntity>({
+  ...{
+  name: "test",
+  idField: "id",
+  fields: {}
+},
+  storage: new ApiStorage<TestEntity>(storageOptions)
+})

package/src/index.ts

@@ -166,12 +166,6 @@ export {
   type SemanticBreadcrumbItem,
 } from './composables/useSemanticBreadcrumb'
 export { useDirtyState, type UseDirtyStateReturn } from './composables/useDirtyState'
-export {
-  useForm,
-  type UseFormOptions,
-  type UseFormReturn,
-  type FormAlterConfig,
-} from './composables/useForm'
 export {
   useEntityItemFormPage,
   useEntityItemFormPage as useFormPageBuilder,
@@ -292,7 +286,6 @@ export {
   type UseUserImpersonatorReturn,
   type UserRecord,
 } from './composables/useUserImpersonator'
-export { useCurrentEntity, type UseCurrentEntityReturn } from './composables/useCurrentEntity'
 export {
   useOptionsLookup,
   type UseOptionsLookupConfig,
@@ -300,6 +293,12 @@ export {
   type OptionsLookupItem,
   type OptionsDisplayMode,
 } from './composables/useOptionsLookup'
+export {
+  useApiClient,
+  resolveApiClient,
+  API_CLIENT_INJECTION_KEY,
+  type ApiClientSource,
+} from './api/apiClient'
 export { useChildPage, type UseChildPageReturn } from './composables/useChildPage'
 export { useSidebarState, SIDEBAR_COLLAPSED_KEY } from './composables/useSidebarState'