@svadmin/core 0.0.3 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/core",
-  "version": "0.0.3",
+  "version": "0.3.0",
   "description": "Core SDK — hooks, types, context, i18n, permissions, router",
   "type": "module",
   "sideEffects": false,
@@ -56,5 +56,8 @@
   "homepage": "https://github.com/zuohuadong/svadmin#readme",
   "bugs": {
     "url": "https://github.com/zuohuadong/svadmin/issues"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.3.11"
   }
 }

package/src/audit.ts

@@ -1,4 +1,5 @@
 // Audit logging — record admin operations
+// Full AuditLogProvider interface
 
 export interface AuditEntry {
   timestamp: string;
@@ -7,22 +8,58 @@ export interface AuditEntry {
   recordId?: string | number;
   userId?: string;
   details?: Record<string, unknown>;
+  data?: Record<string, unknown>;
+  previousData?: Record<string, unknown>;
+  meta?: Record<string, unknown>;
 }
 
 export type AuditHandler = (entry: AuditEntry) => void | Promise<void>;
 
+/**
+ * Full AuditLogProvider interface.
+ * - create: log a new entry
+ * - get: retrieve entries for a resource
+ * - update: update an existing entry (e.g. mark as reviewed)
+ */
+export interface AuditLogProvider {
+  create: (params: { resource: string; action: string; data?: Record<string, unknown>; previousData?: Record<string, unknown>; meta?: Record<string, unknown> }) => Promise<AuditEntry>;
+  get: (params: { resource: string; action?: string; meta?: Record<string, unknown>; author?: Record<string, unknown> }) => Promise<AuditEntry[]>;
+  update: (params: { id: string | number; name: string; meta?: Record<string, unknown> }) => Promise<AuditEntry>;
+}
+
 let handler: AuditHandler = (entry) => {
   console.info('[audit]', entry.action, entry.resource, entry.recordId);
 };
 
+let auditLogProvider: AuditLogProvider | null = null;
+
 export function setAuditHandler(fn: AuditHandler): void {
   handler = fn;
 }
 
+export function setAuditLogProvider(provider: AuditLogProvider): void {
+  auditLogProvider = provider;
+}
+
+export function getAuditLogProvider(): AuditLogProvider | null {
+  return auditLogProvider;
+}
+
 export function audit(entry: Omit<AuditEntry, 'timestamp'>): void {
   const fullEntry: AuditEntry = { ...entry, timestamp: new Date().toISOString() };
   try {
     handler(fullEntry);
+
+    // Also log via provider if set
+    if (auditLogProvider) {
+      auditLogProvider.create({
+        resource: entry.resource ?? '',
+        action: entry.action,
+        data: entry.data ?? entry.details,
+        previousData: entry.previousData,
+        meta: entry.meta,
+      }).catch(e => console.error('[audit] provider create error:', e));
+    }
   } catch (e) {
     console.error('[audit] handler error:', e);
   }

package/src/auth-hooks.svelte.ts

@@ -0,0 +1,293 @@
+// 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.
+
+import { getAuthProvider } from './context';
+import { navigate } from './router';
+import { toast } from './toast.svelte';
+import { t } from './i18n.svelte';
+import type { AuthActionResult, CheckResult, Identity } from './types';
+
+// ─── useLogin ─────────────────────────────────────────────────
+
+export function useLogin() {
+  const provider = getAuthProvider();
+  let isLoading = $state(false);
+
+  async function mutate(params: Record<string, unknown>): Promise<AuthActionResult> {
+    if (!provider) throw new Error('AuthProvider not configured');
+    isLoading = true;
+    try {
+      const result = await provider.login(params);
+      if (result.success) {
+        toast.success(t('common.operationSuccess'));
+        if (result.redirectTo) navigate(result.redirectTo);
+      } else {
+        const msg = result.error?.message ?? t('common.loginFailed');
+        toast.error(msg);
+      }
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : t('common.loginFailed');
+      toast.error(msg);
+      return { success: false, error: { message: msg } };
+    } finally {
+      isLoading = false;
+    }
+  }
+
+  return {
+    mutate,
+    get isLoading() { return isLoading; },
+  };
+}
+
+// ─── useLogout ────────────────────────────────────────────────
+
+export function useLogout() {
+  const provider = getAuthProvider();
+  let isLoading = $state(false);
+
+  async function mutate(params?: Record<string, unknown>): Promise<AuthActionResult> {
+    if (!provider) throw new Error('AuthProvider not configured');
+    isLoading = true;
+    try {
+      const result = await provider.logout(params);
+      if (result.success) {
+        navigate(result.redirectTo ?? '/login');
+      }
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : t('common.operationFailed');
+      toast.error(msg);
+      return { success: false, error: { message: msg } };
+    } finally {
+      isLoading = false;
+    }
+  }
+
+  return {
+    mutate,
+    get isLoading() { return isLoading; },
+  };
+}
+
+// ─── useRegister ──────────────────────────────────────────────
+
+export function useRegister() {
+  const provider = getAuthProvider();
+  let isLoading = $state(false);
+
+  async function mutate(params: Record<string, unknown>): Promise<AuthActionResult> {
+    if (!provider?.register) throw new Error('AuthProvider.register not implemented');
+    isLoading = true;
+    try {
+      const result = await provider.register(params);
+      if (result.success) {
+        toast.success(t('auth.registerSuccess'));
+        if (result.redirectTo) navigate(result.redirectTo);
+      } else {
+        const msg = result.error?.message ?? t('common.operationFailed');
+        toast.error(msg);
+      }
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : t('common.operationFailed');
+      toast.error(msg);
+      return { success: false, error: { message: msg } };
+    } finally {
+      isLoading = false;
+    }
+  }
+
+  return {
+    mutate,
+    get isLoading() { return isLoading; },
+  };
+}
+
+// ─── useForgotPassword ───────────────────────────────────────
+
+export function useForgotPassword() {
+  const provider = getAuthProvider();
+  let isLoading = $state(false);
+
+  async function mutate(params: Record<string, unknown>): Promise<AuthActionResult> {
+    if (!provider?.forgotPassword) throw new Error('AuthProvider.forgotPassword not implemented');
+    isLoading = true;
+    try {
+      const result = await provider.forgotPassword(params);
+      if (result.success) {
+        toast.success(t('auth.resetLinkSent'));
+      } else {
+        const msg = result.error?.message ?? t('common.operationFailed');
+        toast.error(msg);
+      }
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : t('common.operationFailed');
+      toast.error(msg);
+      return { success: false, error: { message: msg } };
+    } finally {
+      isLoading = false;
+    }
+  }
+
+  return {
+    mutate,
+    get isLoading() { return isLoading; },
+  };
+}
+
+// ─── useUpdatePassword ───────────────────────────────────────
+
+export function useUpdatePassword() {
+  const provider = getAuthProvider();
+  let isLoading = $state(false);
+
+  async function mutate(params: Record<string, unknown>): Promise<AuthActionResult> {
+    if (!provider?.updatePassword) throw new Error('AuthProvider.updatePassword not implemented');
+    isLoading = true;
+    try {
+      const result = await provider.updatePassword(params);
+      if (result.success) {
+        toast.success(t('common.operationSuccess'));
+        if (result.redirectTo) navigate(result.redirectTo);
+      } else {
+        const msg = result.error?.message ?? t('common.operationFailed');
+        toast.error(msg);
+      }
+      return result;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : t('common.operationFailed');
+      toast.error(msg);
+      return { success: false, error: { message: msg } };
+    } finally {
+      isLoading = false;
+    }
+  }
+
+  return {
+    mutate,
+    get isLoading() { return isLoading; },
+  };
+}
+
+// ─── useGetIdentity ──────────────────────────────────────────
+
+export function useGetIdentity() {
+  const provider = getAuthProvider();
+  let data = $state<Identity | null>(null);
+  let isLoading = $state(true);
+  let error = $state<Error | null>(null);
+
+  if (provider) {
+    provider.getIdentity().then(identity => {
+      data = identity;
+      isLoading = false;
+    }).catch(err => {
+      error = err instanceof Error ? err : new Error(String(err));
+      isLoading = false;
+      console.warn('[svadmin] useGetIdentity failed:', err);
+    });
+  } else {
+    isLoading = false;
+  }
+
+  return {
+    get data() { return data; },
+    get isLoading() { return isLoading; },
+    get error() { return error; },
+  };
+}
+
+// ─── useIsAuthenticated ──────────────────────────────────────
+
+export function useIsAuthenticated() {
+  const provider = getAuthProvider();
+  let isAuthenticated = $state(false);
+  let isLoading = $state(true);
+
+  if (provider) {
+    provider.check().then((result: CheckResult) => {
+      isAuthenticated = result.authenticated;
+      isLoading = false;
+    }).catch(() => {
+      isAuthenticated = false;
+      isLoading = false;
+    });
+  } else {
+    // No auth provider — treat as authenticated
+    isAuthenticated = true;
+    isLoading = false;
+  }
+
+  return {
+    get isAuthenticated() { return isAuthenticated; },
+    get isLoading() { return isLoading; },
+  };
+}
+
+// ─── useOnError ──────────────────────────────────────────────
+
+/**
+ * Handles errors from data hooks by calling authProvider.onError().
+ * If the provider returns { logout: true }, triggers logout flow.
+ * If it returns { redirectTo }, navigates there.
+ */
+export function useOnError() {
+  const provider = getAuthProvider();
+
+  async function mutate(error: unknown) {
+    if (!provider?.onError) {
+      console.warn('[svadmin] useOnError: authProvider.onError not implemented');
+      return;
+    }
+    try {
+      const result = await provider.onError(error);
+      if (result.logout) {
+        await provider.logout?.();
+        navigate(result.redirectTo ?? '/login');
+      } else if (result.redirectTo) {
+        navigate(result.redirectTo);
+      }
+    } catch (err) {
+      console.warn('[svadmin] useOnError failed:', err);
+    }
+  }
+
+  return { mutate };
+}
+
+// ─── usePermissions ──────────────────────────────────────────
+
+/**
+ * Fetches permissions from authProvider.getPermissions().
+ * Returns a reactive object with data, isLoading, and error.
+ */
+export function usePermissions<T = unknown>() {
+  const provider = getAuthProvider();
+  let data = $state<T | null>(null);
+  let isLoading = $state(true);
+  let error = $state<Error | null>(null);
+
+  if (provider?.getPermissions) {
+    provider.getPermissions().then(permissions => {
+      data = permissions as T;
+      isLoading = false;
+    }).catch(err => {
+      error = err instanceof Error ? err : new Error(String(err));
+      isLoading = false;
+      console.warn('[svadmin] usePermissions failed:', err);
+    });
+  } else {
+    isLoading = false;
+  }
+
+  return {
+    get data() { return data; },
+    get isLoading() { return isLoading; },
+    get error() { return error; },
+  };
+}

package/src/auth-hooks.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Auth Hooks — Unit Tests
+ *
+ * These test the auth hook *logic* by mocking the Svelte context module
+ * so `getAuthProvider()` returns a mock provider without needing a real component tree.
+ */
+import { describe, test, expect, mock, beforeEach } from 'bun:test';
+import type { AuthProvider, AuthActionResult, CheckResult, Identity } from './types';
+
+// Build a mock AuthProvider factory
+function createMockAuthProvider(overrides: Partial<AuthProvider> = {}): AuthProvider {
+  return {
+    login: mock(async () => ({ success: true, redirectTo: '/' } as AuthActionResult)),
+    logout: mock(async () => ({ success: true, redirectTo: '/login' } as AuthActionResult)),
+    check: mock(async () => ({ authenticated: true } as CheckResult)),
+    getIdentity: mock(async () => ({ id: '1', name: 'Admin', email: 'admin@test.com' } as Identity)),
+    register: mock(async () => ({ success: true } as AuthActionResult)),
+    forgotPassword: mock(async () => ({ success: true } as AuthActionResult)),
+    updatePassword: mock(async () => ({ success: true } as AuthActionResult)),
+    onError: mock(async () => ({ logout: false })),
+    getPermissions: mock(async () => ['admin', 'editor']),
+    ...overrides,
+  };
+}
+
+// ─── Tests for AuthProvider mock interface ───────────────────
+
+describe('AuthProvider mock interface', () => {
+  test('login returns success', async () => {
+    const provider = createMockAuthProvider();
+    const result = await provider.login({ email: 'test@test.com', password: '123' });
+    expect(result.success).toBe(true);
+    expect(result.redirectTo).toBe('/');
+    expect(provider.login).toHaveBeenCalledTimes(1);
+  });
+
+  test('login returns failure', async () => {
+    const provider = createMockAuthProvider({
+      login: mock(async () => ({ success: false, error: { message: 'Invalid credentials' } })),
+    });
+    const result = await provider.login({ email: 'bad', password: 'bad' });
+    expect(result.success).toBe(false);
+    expect(result.error?.message).toBe('Invalid credentials');
+  });
+
+  test('logout returns success with redirect', async () => {
+    const provider = createMockAuthProvider();
+    const result = await provider.logout!();
+    expect(result.success).toBe(true);
+    expect(result.redirectTo).toBe('/login');
+  });
+
+  test('check returns authenticated', async () => {
+    const provider = createMockAuthProvider();
+    const result = await provider.check();
+    expect(result.authenticated).toBe(true);
+  });
+
+  test('check returns not authenticated', async () => {
+    const provider = createMockAuthProvider({
+      check: mock(async () => ({ authenticated: false, redirectTo: '/login' })),
+    });
+    const result = await provider.check();
+    expect(result.authenticated).toBe(false);
+    expect(result.redirectTo).toBe('/login');
+  });
+
+  test('getIdentity returns user info', async () => {
+    const provider = createMockAuthProvider();
+    const identity = await provider.getIdentity();
+    expect(identity).not.toBeNull();
+    expect(identity!.name).toBe('Admin');
+    expect(identity!.email).toBe('admin@test.com');
+  });
+
+  test('getIdentity returns null when not logged in', async () => {
+    const provider = createMockAuthProvider({
+      getIdentity: mock(async () => null),
+    });
+    const identity = await provider.getIdentity();
+    expect(identity).toBeNull();
+  });
+
+  test('register returns success', async () => {
+    const provider = createMockAuthProvider();
+    const result = await provider.register!({ email: 'new@test.com', password: '123' });
+    expect(result.success).toBe(true);
+  });
+
+  test('forgotPassword returns success', async () => {
+    const provider = createMockAuthProvider();
+    const result = await provider.forgotPassword!({ email: 'test@test.com' });
+    expect(result.success).toBe(true);
+  });
+
+  test('updatePassword returns success', async () => {
+    const provider = createMockAuthProvider();
+    const result = await provider.updatePassword!({ password: 'newpass', confirmPassword: 'newpass' });
+    expect(result.success).toBe(true);
+  });
+
+  test('onError with logout flag', async () => {
+    const provider = createMockAuthProvider({
+      onError: mock(async () => ({ logout: true, redirectTo: '/login' })),
+    });
+    const result = await provider.onError!(new Error('401'));
+    expect(result.logout).toBe(true);
+    expect(result.redirectTo).toBe('/login');
+  });
+
+  test('onError without logout', async () => {
+    const provider = createMockAuthProvider({
+      onError: mock(async () => ({ logout: false, redirectTo: '/error' })),
+    });
+    const result = await provider.onError!(new Error('500'));
+    expect(result.logout).toBe(false);
+    expect(result.redirectTo).toBe('/error');
+  });
+
+  test('getPermissions returns permissions array', async () => {
+    const provider = createMockAuthProvider();
+    const permissions = await provider.getPermissions!();
+    expect(permissions).toEqual(['admin', 'editor']);
+  });
+
+  test('getPermissions can return custom structure', async () => {
+    const provider = createMockAuthProvider({
+      getPermissions: mock(async () => ({ role: 'admin', canDelete: true })),
+    });
+    const permissions = await provider.getPermissions!() as { role: string; canDelete: boolean };
+    expect(permissions.role).toBe('admin');
+    expect(permissions.canDelete).toBe(true);
+  });
+});
+
+// ─── Tests for auth logic patterns ──────────────────────────
+
+describe('auth hook patterns', () => {
+  test('login flow: success triggers redirect', async () => {
+    const provider = createMockAuthProvider();
+    const result = await provider.login({ email: 'admin@test.com', password: 'pass' });
+    expect(result.success).toBe(true);
+    // In real hook: navigate(result.redirectTo)
+    expect(result.redirectTo).toBeDefined();
+  });
+
+  test('login flow: failure shows error', async () => {
+    const provider = createMockAuthProvider({
+      login: mock(async () => ({ success: false, error: { message: 'Bad password' } })),
+    });
+    const result = await provider.login({ email: 'admin@test.com', password: 'wrong' });
+    expect(result.success).toBe(false);
+    // In real hook: toast.error(result.error.message)
+    expect(result.error?.message).toBe('Bad password');
+  });
+
+  test('login flow: exception produces error result', async () => {
+    const provider = createMockAuthProvider({
+      login: mock(async () => { throw new Error('Network Error'); }),
+    });
+    try {
+      await provider.login({ email: 'test', password: 'test' });
+      expect(true).toBe(false); // should not reach
+    } catch (err) {
+      expect((err as Error).message).toBe('Network Error');
+    }
+  });
+
+  test('onError flow: 401 triggers logout + redirect', async () => {
+    const provider = createMockAuthProvider({
+      onError: mock(async (err: unknown) => {
+        if (err instanceof Error && err.message.includes('401')) {
+          return { logout: true, redirectTo: '/login' };
+        }
+        return { logout: false };
+      }),
+    });
+    const result = await provider.onError!(new Error('401 Unauthorized'));
+    expect(result.logout).toBe(true);
+    // In real hook: provider.logout() then navigate(result.redirectTo)
+  });
+
+  test('onError flow: 500 does not trigger logout', async () => {
+    const provider = createMockAuthProvider({
+      onError: mock(async (err: unknown) => {
+        if (err instanceof Error && err.message.includes('401')) {
+          return { logout: true, redirectTo: '/login' };
+        }
+        return { logout: false };
+      }),
+    });
+    const result = await provider.onError!(new Error('500 Internal Server Error'));
+    expect(result.logout).toBe(false);
+  });
+
+  test('check → getIdentity flow', async () => {
+    const provider = createMockAuthProvider();
+    const checkResult = await provider.check();
+    expect(checkResult.authenticated).toBe(true);
+    if (checkResult.authenticated) {
+      const identity = await provider.getIdentity();
+      expect(identity!.name).toBe('Admin');
+    }
+  });
+});