@svadmin/core 0.0.6 → 0.4.1

package/package.json

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

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

@@ -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/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');
+    }
+  });
+});

package/src/context.svelte.ts

@@ -0,0 +1,123 @@
+// 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 type { DataProvider, AuthProvider, ResourceDefinition } from './types';
+import type { RouterProvider } from './router-provider';
+
+// ─── DataProvider (supports single or multiple) ─────────────────
+
+/**
+ * Accepts either:
+ *   - A single DataProvider (backwards compatible)
+ *   - A record of named providers: { default: rest, cms: graphql }
+ */
+export type DataProviderInput = DataProvider | Record<string, DataProvider>;
+
+let providers = $state<Record<string, DataProvider> | null>(null);
+
+export function setDataProvider(provider: DataProviderInput): void {
+  if (isDataProvider(provider)) {
+    providers = { default: provider } as Record<string, DataProvider>;
+  } else {
+    providers = provider as Record<string, DataProvider>;
+  }
+}
+
+export function getDataProvider(name?: string): DataProvider {
+  if (!providers) throw new Error('DataProvider not found. Did you call setDataProvider in App.svelte?');
+  const key = name ?? 'default';
+  const provider = providers[key];
+  if (!provider) {
+    throw new Error(`DataProvider "${key}" not found. Available: ${Object.keys(providers).join(', ')}`);
+  }
+  return provider;
+}
+
+export function getDataProviderNames(): string[] {
+  return providers ? Object.keys(providers) : [];
+}
+
+export function getDataProviderForResource(resourceName: string, overrideName?: string): DataProvider {
+  if (overrideName) {
+    try {
+      return getDataProvider(overrideName);
+    } catch {
+      // ignore
+    }
+  }
+  try {
+    const resource = getResource(resourceName);
+    const dpName = resource.meta?.dataProviderName as string | undefined;
+    if (dpName) return getDataProvider(dpName);
+  } catch {
+    // ignore
+  }
+  return getDataProvider();
+}
+
+function isDataProvider(value: unknown): value is DataProvider {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    'getList' in value &&
+    typeof (value as DataProvider).getList === 'function'
+  );
+}
+
+// ─── Auth Provider ──────────────────────────────────────────────
+
+let authProvider = $state<AuthProvider | null>(null);
+
+export function setAuthProvider(provider: AuthProvider): void {
+  authProvider = provider;
+}
+
+export function getAuthProvider(): AuthProvider {
+  if (!authProvider) throw new Error('AuthProvider not found. Did you call setAuthProvider in App.svelte?');
+  return authProvider;
+}
+
+// ─── Resources ──────────────────────────────────────────────────
+
+let resources = $state.raw<ResourceDefinition[]>([]);
+
+export function setResources(newResources: ResourceDefinition[]): void {
+  resources = newResources;
+}
+
+export function getResources(): ResourceDefinition[] {
+  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 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 {
+  routerProvider = provider;
+}
+
+export function getRouterProvider(): RouterProvider | undefined {
+  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;
+}