@svadmin/core 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/core",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Core SDK — hooks, types, context, i18n, permissions, router",
   "type": "module",
   "sideEffects": false,
@@ -51,7 +51,8 @@
   "author": "zuohuadong",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/zuohuadong/svadmin.git"
+    "url": "https://github.com/zuohuadong/svadmin.git",
+    "directory": "packages/core"
   },
   "homepage": "https://github.com/zuohuadong/svadmin#readme",
   "bugs": {
@@ -59,5 +60,8 @@
   },
   "devDependencies": {
     "@types/bun": "^1.3.11"
+  },
+  "dependencies": {
+    "svelte-sonner": "^1.1.0"
   }
 }

package/src/adapters/casbin.ts

@@ -0,0 +1,61 @@
+/**
+ * Casbin adapter for svadmin AccessControlProvider.
+ *
+ * Converts a Casbin `Enforcer` instance into an `AccessControlProvider`.
+ *
+ * @example
+ * ```ts
+ * import { newEnforcer } from 'casbin';
+ * import { createCasbinAccessControl } from '@svadmin/core/adapters/casbin';
+ * import { setAccessControlProvider } from '@svadmin/core';
+ *
+ * const enforcer = await newEnforcer('model.conf', 'policy.csv');
+ * const currentUser = 'alice';
+ *
+ * setAccessControlProvider(
+ *   createCasbinAccessControl(enforcer, { getUser: () => currentUser })
+ * );
+ * ```
+ */
+
+import type { AccessControlProvider, CanParams, CanResult } from '../permissions';
+
+/** Casbin Enforcer interface (minimal, to avoid hard dependency on casbin) */
+interface CasbinEnforcer {
+  enforce: (...args: string[]) => Promise<boolean>;
+}
+
+export interface CasbinAdapterOptions {
+  /** Function to get the current user/subject for enforcement. */
+  getUser: () => string;
+  /** Provider-level options */
+  providerOptions?: AccessControlProvider['options'];
+}
+
+/**
+ * Create an AccessControlProvider from a Casbin Enforcer.
+ *
+ * Uses the standard (sub, obj, act) enforcement model:
+ * - sub = current user (from `getUser()`)
+ * - obj = resource name
+ * - act = action
+ *
+ * @param enforcer - A Casbin Enforcer instance
+ * @param options - Configuration with user getter
+ */
+export function createCasbinAccessControl(
+  enforcer: CasbinEnforcer,
+  options: CasbinAdapterOptions,
+): AccessControlProvider {
+  return {
+    can: async ({ resource, action }: CanParams): Promise<CanResult> => {
+      const user = options.getUser();
+      const allowed = await enforcer.enforce(user, resource, action);
+      return {
+        can: allowed,
+        reason: allowed ? undefined : `User "${user}" cannot "${action}" on "${resource}"`,
+      };
+    },
+    options: options.providerOptions,
+  };
+}

package/src/adapters/casl.ts

@@ -0,0 +1,51 @@
+/**
+ * CASL adapter for svadmin AccessControlProvider.
+ *
+ * Converts a CASL `Ability` instance into an `AccessControlProvider`.
+ *
+ * @example
+ * ```ts
+ * import { AbilityBuilder, createMongoAbility } from '@casl/ability';
+ * import { createCaslAccessControl } from '@svadmin/core/adapters/casl';
+ * import { setAccessControlProvider } from '@svadmin/core';
+ *
+ * const { can, build } = new AbilityBuilder(createMongoAbility);
+ * can('read', 'Post');
+ * can('create', 'Post');
+ * can('manage', 'User');
+ * const ability = build();
+ *
+ * setAccessControlProvider(createCaslAccessControl(ability));
+ * ```
+ */
+
+import type { AccessControlProvider, CanParams, CanResult } from '../permissions';
+
+/** CASL Ability interface (minimal, to avoid hard dependency on @casl/ability) */
+interface CaslAbility {
+  can: (action: string, subject: string, field?: string) => boolean;
+  cannot: (action: string, subject: string, field?: string) => boolean;
+}
+
+/**
+ * Create an AccessControlProvider from a CASL Ability.
+ *
+ * @param ability - A CASL Ability instance
+ * @param options - Optional configuration
+ */
+export function createCaslAccessControl(
+  ability: CaslAbility,
+  options?: AccessControlProvider['options'],
+): AccessControlProvider {
+  return {
+    can: async ({ resource, action, params }: CanParams): Promise<CanResult> => {
+      const field = params?.field as string | undefined;
+      const allowed = ability.can(action, resource, field);
+      return {
+        can: allowed,
+        reason: allowed ? undefined : `Cannot "${action}" on "${resource}"${field ? ` (field: ${field})` : ''}`,
+      };
+    },
+    options,
+  };
+}

package/src/auth-hooks.svelte.ts

@@ -1,9 +1,8 @@
 // Auth Hooks — reactive wrappers around AuthProvider methods
 // Each hook encapsulates the auth call + loading state + error handling + redirect
-// IMPORTANT: getAuthProvider() must be called at hook creation time (during component init),
-//            not inside mutate(), because Svelte's getContext() only works during init.
+// Uses module-level $state — no component init-time constraints.
 
-import { getAuthProvider } from './context';
+import { getAuthProvider } from './context.svelte';
 import { navigate } from './router';
 import { toast } from './toast.svelte';
 import { t } from './i18n.svelte';

package/src/{context.ts → context.svelte.ts}

@@ -1,14 +1,9 @@
-// Svelte context — provides DataProvider, AuthProvider, and Resources to all components
+// Svelte 5 Context — module-level $state singletons (no setContext/getContext required)
+// This removes the constraint that hooks must be called at component init time.
 
-import { getContext, setContext } from 'svelte';
 import type { DataProvider, AuthProvider, ResourceDefinition } from './types';
 import type { RouterProvider } from './router-provider';
 
-const DATA_PROVIDER_KEY = Symbol('data-provider');
-const AUTH_PROVIDER_KEY = Symbol('auth-provider');
-const RESOURCES_KEY = Symbol('resources');
-const ROUTER_PROVIDER_KEY = Symbol('router-provider');
-
 // ─── DataProvider (supports single or multiple) ─────────────────
 
 /**
@@ -18,16 +13,17 @@ const ROUTER_PROVIDER_KEY = Symbol('router-provider');
  */
 export type DataProviderInput = DataProvider | Record<string, DataProvider>;
 
+let providers = $state<Record<string, DataProvider> | null>(null);
+
 export function setDataProvider(provider: DataProviderInput): void {
   if (isDataProvider(provider)) {
-    setContext(DATA_PROVIDER_KEY, { default: provider } as Record<string, DataProvider>);
+    providers = { default: provider } as Record<string, DataProvider>;
   } else {
-    setContext(DATA_PROVIDER_KEY, provider as Record<string, DataProvider>);
+    providers = provider as Record<string, DataProvider>;
   }
 }
 
 export function getDataProvider(name?: string): DataProvider {
-  const providers = getContext<Record<string, DataProvider>>(DATA_PROVIDER_KEY);
   if (!providers) throw new Error('DataProvider not found. Did you call setDataProvider in App.svelte?');
   const key = name ?? 'default';
   const provider = providers[key];
@@ -38,7 +34,6 @@ export function getDataProvider(name?: string): DataProvider {
 }
 
 export function getDataProviderNames(): string[] {
-  const providers = getContext<Record<string, DataProvider>>(DATA_PROVIDER_KEY);
   return providers ? Object.keys(providers) : [];
 }
 
@@ -71,41 +66,58 @@ function isDataProvider(value: unknown): value is DataProvider {
 
 // ─── Auth Provider ──────────────────────────────────────────────
 
+let authProvider = $state<AuthProvider | null>(null);
+
 export function setAuthProvider(provider: AuthProvider): void {
-  setContext(AUTH_PROVIDER_KEY, provider);
+  authProvider = provider;
 }
 
 export function getAuthProvider(): AuthProvider {
-  const provider = getContext<AuthProvider>(AUTH_PROVIDER_KEY);
-  if (!provider) throw new Error('AuthProvider not found. Did you call setAuthProvider in App.svelte?');
-  return provider;
+  if (!authProvider) throw new Error('AuthProvider not found. Did you call setAuthProvider in App.svelte?');
+  return authProvider;
 }
 
 // ─── Resources ──────────────────────────────────────────────────
 
-export function setResources(resources: ResourceDefinition[]): void {
-  setContext(RESOURCES_KEY, resources);
+let resources = $state.raw<ResourceDefinition[]>([]);
+
+export function setResources(newResources: ResourceDefinition[]): void {
+  resources = newResources;
 }
 
 export function getResources(): ResourceDefinition[] {
-  const resources = getContext<ResourceDefinition[]>(RESOURCES_KEY);
-  if (!resources) throw new Error('Resources not found. Did you call setResources in App.svelte?');
+  if (!resources || resources.length === 0) throw new Error('Resources not found. Did you call setResources in App.svelte?');
   return resources;
 }
 
 export function getResource(nameOrIdentifier: string): ResourceDefinition {
-  const resources = getResources();
-  const resource = resources.find(r => r.identifier === nameOrIdentifier || r.name === nameOrIdentifier);
+  const rList = getResources();
+  const resource = rList.find(r => r.identifier === nameOrIdentifier || r.name === nameOrIdentifier);
   if (!resource) throw new Error(`Resource "${nameOrIdentifier}" not found in resource definitions.`);
   return resource;
 }
 
 // ─── Router Provider ────────────────────────────────────────────
 
+let routerProvider = $state<RouterProvider | undefined>(undefined);
+
 export function setRouterProvider(provider: RouterProvider): void {
-  setContext(ROUTER_PROVIDER_KEY, provider);
+  routerProvider = provider;
 }
 
 export function getRouterProvider(): RouterProvider | undefined {
-  return getContext<RouterProvider>(ROUTER_PROVIDER_KEY);
+  return routerProvider;
+}
+
+
+// ─── Live Provider ──────────────────────────────────────────────
+
+let liveProviderState: import('./live').LiveProvider | undefined = undefined;
+
+export function setLiveProvider(provider: import('./live').LiveProvider): void {
+  liveProviderState = provider;
+}
+
+export function getLiveProvider(): import('./live').LiveProvider | undefined {
+  return liveProviderState;
 }

package/src/data-transfer.ts

@@ -1,4 +1,4 @@
-import { getDataProviderForResource } from './context';
+import { getDataProviderForResource } from './context.svelte';
 import { useParsed } from './useParsed';
 import type { GetListResult, Sort, Filter, BaseRecord } from './types';
 

package/src/form-hooks.svelte.ts

@@ -1,7 +1,7 @@
 import { useQueryClient } from '@tanstack/svelte-query';
 import { useParsed } from './useParsed';
 import { getAdminOptions } from './options';
-import { getDataProviderForResource } from './context';
+import { getDataProviderForResource } from './context.svelte';
 import { createQuery, createMutation } from '@tanstack/svelte-query';
 import { toast } from './toast.svelte';
 import { t } from './i18n.svelte';
@@ -103,7 +103,7 @@ export function useForm<
   let errors = $state<Record<string, string>>({});
   function setFieldError(field: string, message: string) { errors = { ...errors, [field]: message }; }
   function clearErrors() { errors = {}; }
-  function clearFieldError(field: string) { const next = { ...errors }; delete next[field]; errors = next; }
+  function clearFieldError(field: string) { delete errors[field]; }
 
   function runValidation(values: TVariables): boolean {
     clearErrors();
@@ -178,14 +178,14 @@ export function useForm<
   async function onFinish(values: TVariables, finishOptions?: { redirect?: 'list' | 'edit' | 'show' | false }) {
     if (!runValidation(values)) { toast.warning(t('validation.required')); return; }
     redirectOverride = finishOptions?.redirect;
-    if (action === 'create' || action === 'clone') await (createMut as any).mutateAsync(values);
-    else await (updateMut as any).mutateAsync(values);
+    if (action === 'create' || action === 'clone') await createMut.mutateAsync(values);
+    else await updateMut.mutateAsync(values);
   }
 
   async function onFinishAutoSave(values: TVariables) {
     if (action === 'create' || action === 'clone') return; // Only autosave on edit
     redirectOverride = false; // Never redirect on autoSave
-    await (updateMut as any).mutateAsync(values);
+    await updateMut.mutateAsync(values);
   }
 
   let autoSaveStatus = $state<'idle' | 'saving' | 'saved' | 'error'>('idle');
@@ -244,7 +244,7 @@ export function useForm<
 
   return {
     query,
-    get formLoading() { return ((query as any)?.isLoading ?? false) || (createMut as any).isPending || (updateMut as any).isPending; },
+    get formLoading() { return (query?.isLoading ?? false) || createMut.isPending || updateMut.isPending; },
     mutation: action === 'edit' ? updateMut : createMut,
     onFinish,
     onFinishAutoSave,

package/src/hooks.svelte.ts

@@ -23,7 +23,7 @@ export type { OvertimeResult, OvertimeOptions, NotificationConfig } from './hook
 
 import { createQuery, createInfiniteQuery, createMutation, useQueryClient } from '@tanstack/svelte-query';
 import { getAdminOptions } from './options';
-import { getDataProviderForResource, getDataProvider } from './context';
+import { getDataProviderForResource, getDataProvider } from './context.svelte';
 import { useParsed } from './useParsed';
 import { createOvertimeTracker, fireSuccessNotification, fireErrorNotification } from './hook-utils.svelte';
 import type { NotificationConfig, OvertimeOptions } from './hook-utils.svelte';
@@ -203,7 +203,7 @@ export function useCustom<TData = unknown, TError = HttpError>(options: UseCusto
       return provider.custom<TData>({
         url: options.url,
         method: options.method,
-        payload: options.config?.payload as any,
+        payload: options.config?.payload,
         query: options.config?.query,
         headers: options.config?.headers,
         sorters: options.config?.sorters,
@@ -229,7 +229,7 @@ export function useCustomMutation<TData = unknown, TError = HttpError, TVariable
   const mutation = createMutation<{ data: TData }, TError, { url: string; method: 'get' | 'post' | 'put' | 'patch' | 'delete'; values?: TVariables; meta?: Record<string, unknown> }>(() => ({
     mutationFn: async (params) => {
       if (!provider.custom) throw new Error('DataProvider does not support custom method');
-      return provider.custom<TData>({ url: params.url, method: params.method, payload: params.values as any, meta: params.meta });
+      return provider.custom<TData>({ url: params.url, method: params.method, payload: params.values, meta: params.meta });
     },
   }));
 

package/src/i18n.svelte.ts

@@ -38,6 +38,9 @@ const locales: Record<string, Locale> = {
     'common.home': '首页',
     'common.logout': '退出登录',
     'common.toggleTheme': '切换主题',
+    'common.switchLanguage': '切换语言',
+    'common.clear': '清除',
+    'common.menu': '菜单',
     'common.darkMode': '暗色模式',
     'common.lightMode': '亮色模式',
     'common.detail': '详情',
@@ -47,19 +50,39 @@ const locales: Record<string, Locale> = {
     'common.retry': '重试',
     'common.yes': '是',
     'common.no': '否',
+    'common.undo': '撤销',
+    'common.filter': '筛选',
+    'common.reset': '重置',
     'common.welcome': '欢迎使用 {title}',
     'common.dashboardHint': '从侧边栏选择一个资源开始。',
     'common.redirecting': '正在跳转到登录页...',
+    'common.expand': '展开',
+    'common.collapse': '收起',
+    'common.close': '关闭',
+    'common.copy': '复制',
+    'common.copyAll': '复制全部',
+    'common.copied': '已复制',
+    'common.next': '下一步',
+    'common.back': '返回',
+    'common.step': '步骤',
+    'common.columns': '列',
+    'common.perPage': '每页',
+    'common.copyId': '复制 ID',
+    'common.showMore': '展开更多',
+    'common.showLess': '收起',
     // Field
     'field.enterValue': '输入{label}',
     'field.selectPlaceholder': '请选择',
     'field.tagsPlaceholder': '输入标签后按回车...',
+    'field.noOptions': '无可用选项',
+    'field.addImage': '添加图片',
     // Config errors
     'config.missingEnvTitle': '环境配置缺失',
     'config.missingEnvDescription': '应用无法启动，因为缺少必要的环境变量。',
     'config.addToEnvFile': '请在 .env 文件中添加以下内容：',
     'config.envFilePath': '文件路径: .env',
     'config.reload': '配置完成后刷新页面',
+    'config.reloadButton': '重新加载页面',
     // Auth pages
     'auth.login': '登录',
     'auth.register': '注册',
@@ -86,6 +109,17 @@ const locales: Record<string, Locale> = {
     'auth.welcomeMessage': '登录以继续使用管理后台',
     'auth.createAccount': '创建账号',
     'auth.createAccountMessage': '填写信息以创建您的账号',
+    // AutoSave
+    'autoSave.idle': '已保存',
+    'autoSave.saving': '保存中...',
+    'autoSave.saved': '已保存',
+    'autoSave.error': '保存失败',
+    // Empty states
+    'empty.title': '暂无数据',
+    'empty.description': '没有找到符合条件的记录。',
+    'empty.noMore': '没有更多了',
+    // DevTools
+    'devtools.title': '开发者工具 (Ctrl+Shift+D)',
     // Validation
     'validation.required': '此字段为必填项',
     'validation.minLength': '最少 {min} 个字符',
@@ -128,6 +162,9 @@ const locales: Record<string, Locale> = {
     'common.home': 'Home',
     'common.logout': 'Log out',
     'common.toggleTheme': 'Toggle theme',
+    'common.switchLanguage': 'Switch language',
+    'common.clear': 'Clear',
+    'common.menu': 'Menu',
     'common.darkMode': 'Dark mode',
     'common.lightMode': 'Light mode',
     'common.detail': 'Detail',
@@ -137,19 +174,39 @@ const locales: Record<string, Locale> = {
     'common.retry': 'Retry',
     'common.yes': 'Yes',
     'common.no': 'No',
+    'common.undo': 'Undo',
+    'common.filter': 'Filter',
+    'common.reset': 'Reset',
     'common.welcome': 'Welcome to {title}',
     'common.dashboardHint': 'Select a resource from the sidebar to get started.',
     'common.redirecting': 'Redirecting to login...',
+    'common.expand': 'Expand',
+    'common.collapse': 'Collapse',
+    'common.close': 'Close',
+    'common.copy': 'Copy',
+    'common.copyAll': 'Copy All',
+    'common.copied': 'Copied!',
+    'common.next': 'Next',
+    'common.back': 'Back',
+    'common.step': 'Step',
+    'common.columns': 'Columns',
+    'common.perPage': 'per page',
+    'common.copyId': 'Copy ID',
+    'common.showMore': 'Show more',
+    'common.showLess': 'Show less',
     // Field
     'field.enterValue': 'Enter {label}',
     'field.selectPlaceholder': 'Select...',
     'field.tagsPlaceholder': 'Type a tag and press Enter...',
+    'field.noOptions': 'No options available',
+    'field.addImage': 'Add image',
     // Config errors
     'config.missingEnvTitle': 'Missing Configuration',
     'config.missingEnvDescription': 'The app cannot start because required environment variables are missing.',
     'config.addToEnvFile': 'Add the following to your .env file:',
     'config.envFilePath': 'File path: .env',
-    'config.reload': 'Reload after configuration',
+    'config.reload': 'Refresh page after configuration',
+    'config.reloadButton': 'Reload Page',
     // Auth pages
     'auth.login': 'Login',
     'auth.register': 'Register',
@@ -176,6 +233,17 @@ const locales: Record<string, Locale> = {
     'auth.welcomeMessage': 'Sign in to continue to admin panel',
     'auth.createAccount': 'Create Account',
     'auth.createAccountMessage': 'Fill in your details to create an account',
+    // AutoSave
+    'autoSave.idle': 'Saved',
+    'autoSave.saving': 'Saving...',
+    'autoSave.saved': 'Saved',
+    'autoSave.error': 'Save failed',
+    // Empty states
+    'empty.title': 'No data',
+    'empty.description': 'No records found matching your criteria.',
+    'empty.noMore': 'No more items',
+    // DevTools
+    'devtools.title': 'DevTools (Ctrl+Shift+D)',
     // Validation
     'validation.required': 'This field is required',
     'validation.minLength': 'Minimum {min} characters',

package/src/index.ts

@@ -5,8 +5,8 @@ export {
   setAuthProvider, getAuthProvider,
   setResources, getResources, getResource,
   setRouterProvider, getRouterProvider,
-} from './context';
-export type { DataProviderInput } from './context';
+} from './context.svelte';
+export type { DataProviderInput } from './context.svelte';
 export {
   useList, useInfiniteList,
   useOne, useShow,
@@ -28,7 +28,7 @@ export {
 } from './hooks.svelte';
 export { matchRoute, navigate, currentPath, setActiveRouterProvider } from './router';
 export { readURLState, writeURLState } from './url-sync';
-export { setAccessControl, canAccess, canAccessAsync } from './permissions';
+export { setAccessControl, setAccessControlProvider, getAccessControlProvider, getAccessControlOptions, canAccess, canAccessAsync } from './permissions';
 export { useLive, useSubscription, usePublish } from './live';
 export { toast } from './toast.svelte';
 export { notify, closeNotification, setNotificationProvider, getNotificationProvider } from './notification.svelte';
@@ -64,9 +64,13 @@ export type {
 } from './types';
 export type { InvalidateScope } from './options';
 export type { LiveProvider, LiveEvent, LiveMode } from './live';
-export type { Action, AccessControlResult, AccessControlFn } from './permissions';
+export type { Action, CanParams, CanResult, AccessControlProvider, AccessControlResult, AccessControlFn } from './permissions';
 export type { AuditEntry, AuditHandler } from './audit';
 export { useCan } from './useCan';
+export type { UseCanOptions, UseCanResult } from './useCan';
+export { createCaslAccessControl } from './adapters/casl';
+export { createCasbinAccessControl } from './adapters/casbin';
+export type { CasbinAdapterOptions } from './adapters/casbin';
 export { useExport, useImport } from './data-transfer';
 export type { UseExportOptions, UseImportOptions } from './data-transfer';
 export {
@@ -92,3 +96,5 @@ export {
   unionFilters, unionSorters,
   file2Base64, generateDefaultDocumentTitle,
 } from './helpers';
+export { TableState } from './table-state.svelte';
+export type { TableStateOptions } from './table-state.svelte';

package/src/mutation-hooks.svelte.ts

@@ -1,6 +1,6 @@
 import { createMutation, useQueryClient } from '@tanstack/svelte-query';
 import { getAdminOptions } from './options';
-import { getDataProviderForResource } from './context';
+import { getDataProviderForResource } from './context.svelte';
 import { useParsed } from './useParsed';
 import { audit } from './audit';
 import { UndoError } from './types';

package/src/permissions.test.ts

@@ -1,7 +1,7 @@
 // Unit tests for permissions module
 import { describe, test, expect, beforeEach } from 'bun:test';
-import { setAccessControl, canAccess, canAccessAsync } from './permissions';
-import type { Action } from './permissions';
+import { setAccessControl, setAccessControlProvider, getAccessControlProvider, getAccessControlOptions, canAccess, canAccessAsync } from './permissions';
+import type { Action, AccessControlProvider } from './permissions';
 
 describe('permissions', () => {
   beforeEach(() => {
@@ -53,3 +53,122 @@ describe('permissions', () => {
     expect(canAccess('posts', 'delete').can).toBe(true);
   });
 });
+
+describe('AccessControlProvider', () => {
+  beforeEach(() => {
+    setAccessControlProvider({
+      can: async () => ({ can: true }),
+    });
+  });
+
+  test('setAccessControlProvider registers a provider', () => {
+    const provider = getAccessControlProvider();
+    expect(provider).not.toBeNull();
+  });
+
+  test('provider can() is called via canAccessAsync', async () => {
+    setAccessControlProvider({
+      can: async ({ resource, action }) => {
+        if (resource === 'posts' && action === 'delete') {
+          return { can: false, reason: 'Cannot delete posts' };
+        }
+        return { can: true };
+      },
+    });
+    const denied = await canAccessAsync('posts', 'delete');
+    expect(denied.can).toBe(false);
+    expect(denied.reason).toBe('Cannot delete posts');
+
+    const allowed = await canAccessAsync('posts', 'list');
+    expect(allowed.can).toBe(true);
+  });
+
+  test('params.id is passed through', async () => {
+    setAccessControlProvider({
+      can: async ({ params }) => {
+        if (params?.id === 42) return { can: false, reason: 'Record locked' };
+        return { can: true };
+      },
+    });
+    const result = await canAccessAsync('posts', 'edit', { id: 42 });
+    expect(result.can).toBe(false);
+    expect(result.reason).toBe('Record locked');
+  });
+
+  test('extended action types work', async () => {
+    setAccessControlProvider({
+      can: async ({ action }) => {
+        if (action === 'show') return { can: false, reason: 'No show' };
+        if (action === 'field') return { can: false, reason: 'No field' };
+        return { can: true };
+      },
+    });
+    expect((await canAccessAsync('posts', 'show')).can).toBe(false);
+    expect((await canAccessAsync('posts', 'field')).can).toBe(false);
+    expect((await canAccessAsync('posts', 'list')).can).toBe(true);
+  });
+
+  test('getAccessControlOptions returns provider options', () => {
+    setAccessControlProvider({
+      can: async () => ({ can: true }),
+      options: {
+        buttons: { enableAccessControl: true, hideIfUnauthorized: true },
+      },
+    });
+    const options = getAccessControlOptions();
+    expect(options.buttons?.enableAccessControl).toBe(true);
+    expect(options.buttons?.hideIfUnauthorized).toBe(true);
+  });
+
+  test('getAccessControlOptions returns {} when no options', () => {
+    setAccessControlProvider({
+      can: async () => ({ can: true }),
+    });
+    expect(getAccessControlOptions()).toEqual({});
+  });
+});
+
+describe('CASL adapter', () => {
+  test('createCaslAccessControl works', async () => {
+    // Import dynamically to test the adapter
+    const { createCaslAccessControl } = await import('./adapters/casl');
+
+    // Mock CASL Ability
+    const ability = {
+      can: (action: string, subject: string) => !(action === 'delete' && subject === 'users'),
+      cannot: (action: string, subject: string) => action === 'delete' && subject === 'users',
+    };
+
+    const provider = createCaslAccessControl(ability);
+
+    const allowed = await provider.can({ resource: 'posts', action: 'edit' });
+    expect(allowed.can).toBe(true);
+
+    const denied = await provider.can({ resource: 'users', action: 'delete' });
+    expect(denied.can).toBe(false);
+    expect(denied.reason).toContain('Cannot "delete" on "users"');
+  });
+});
+
+describe('Casbin adapter', () => {
+  test('createCasbinAccessControl works', async () => {
+    const { createCasbinAccessControl } = await import('./adapters/casbin');
+
+    // Mock Casbin Enforcer
+    const enforcer = {
+      enforce: async (sub: string, obj: string, act: string) =>
+        !(sub === 'alice' && obj === 'users' && act === 'delete'),
+    };
+
+    const provider = createCasbinAccessControl(enforcer, {
+      getUser: () => 'alice',
+    });
+
+    const allowed = await provider.can({ resource: 'posts', action: 'edit' });
+    expect(allowed.can).toBe(true);
+
+    const denied = await provider.can({ resource: 'users', action: 'delete' });
+    expect(denied.can).toBe(false);
+    expect(denied.reason).toContain('alice');
+  });
+});