@svadmin/core 0.0.6 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/core",
-  "version": "0.0.6",
+  "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.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.ts

@@ -9,26 +9,70 @@ const AUTH_PROVIDER_KEY = Symbol('auth-provider');
 const RESOURCES_KEY = Symbol('resources');
 const ROUTER_PROVIDER_KEY = Symbol('router-provider');
 
-// ─── Setters (called once in App.svelte) ────────────────────────
+// ─── DataProvider (supports single or multiple) ─────────────────
 
-export function setDataProvider(provider: DataProvider): void {
-  setContext(DATA_PROVIDER_KEY, provider);
+/**
+ * Accepts either:
+ *   - A single DataProvider (backwards compatible)
+ *   - A record of named providers: { default: rest, cms: graphql }
+ */
+export type DataProviderInput = DataProvider | Record<string, DataProvider>;
+
+export function setDataProvider(provider: DataProviderInput): void {
+  if (isDataProvider(provider)) {
+    setContext(DATA_PROVIDER_KEY, { default: provider } as Record<string, DataProvider>);
+  } else {
+    setContext(DATA_PROVIDER_KEY, provider as Record<string, DataProvider>);
+  }
 }
 
-export function setAuthProvider(provider: AuthProvider): void {
-  setContext(AUTH_PROVIDER_KEY, provider);
+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];
+  if (!provider) {
+    throw new Error(`DataProvider "${key}" not found. Available: ${Object.keys(providers).join(', ')}`);
+  }
+  return provider;
 }
 
-export function setResources(resources: ResourceDefinition[]): void {
-  setContext(RESOURCES_KEY, resources);
+export function getDataProviderNames(): string[] {
+  const providers = getContext<Record<string, DataProvider>>(DATA_PROVIDER_KEY);
+  return providers ? Object.keys(providers) : [];
 }
 
-// ─── Getters (called from any child component) ──────────────────
+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();
+}
 
-export function getDataProvider(): DataProvider {
-  const provider = getContext<DataProvider>(DATA_PROVIDER_KEY);
-  if (!provider) throw new Error('DataProvider not found. Did you call setDataProvider in App.svelte?');
-  return provider;
+function isDataProvider(value: unknown): value is DataProvider {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    'getList' in value &&
+    typeof (value as DataProvider).getList === 'function'
+  );
+}
+
+// ─── Auth Provider ──────────────────────────────────────────────
+
+export function setAuthProvider(provider: AuthProvider): void {
+  setContext(AUTH_PROVIDER_KEY, provider);
 }
 
 export function getAuthProvider(): AuthProvider {
@@ -37,16 +81,22 @@ export function getAuthProvider(): AuthProvider {
   return provider;
 }
 
+// ─── Resources ──────────────────────────────────────────────────
+
+export function setResources(resources: ResourceDefinition[]): void {
+  setContext(RESOURCES_KEY, resources);
+}
+
 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?');
   return resources;
 }
 
-export function getResource(name: string): ResourceDefinition {
+export function getResource(nameOrIdentifier: string): ResourceDefinition {
   const resources = getResources();
-  const resource = resources.find(r => r.name === name);
-  if (!resource) throw new Error(`Resource "${name}" not found in resource definitions.`);
+  const resource = resources.find(r => r.identifier === nameOrIdentifier || r.name === nameOrIdentifier);
+  if (!resource) throw new Error(`Resource "${nameOrIdentifier}" not found in resource definitions.`);
   return resource;
 }
 

package/src/data-transfer.ts

@@ -1,108 +1,186 @@
-// Data transfer utilities — CSV export/import
-
-import { getDataProvider } from './context';
-import type { GetListResult } from './types';
+import { getDataProviderForResource } from './context';
+import { useParsed } from './useParsed';
+import type { GetListResult, Sort, Filter, BaseRecord } from './types';
+
+export interface UseExportOptions<TData extends BaseRecord = BaseRecord> {
+  resource?: string;
+  mapData?: (item: TData) => Record<string, unknown>;
+  sorters?: Sort[];
+  filters?: Filter[];
+  maxItemCount?: number;
+  pageSize?: number;
+  download?: boolean;
+  meta?: Record<string, unknown>;
+  dataProviderName?: string;
+  onError?: (error: Error) => void;
+}
 
 /**
- * useExport — export all records from a resource as CSV download
+ * useExport — export records from a resource as CSV download
+ * Supports mapData, sorters, filters, maxItemCount, pageSize
  */
-export function useExport(resource: string) {
-  let isExporting = $state(false);
+export function useExport<TData extends BaseRecord = BaseRecord>(options: UseExportOptions<TData> = {}) {
+  const parsed = useParsed();
+  const resource = options.resource ?? parsed.resource ?? '';
+  let isLoading = $state(false);
 
-  async function exportCSV(opts?: { filename?: string; fields?: string[] }) {
-    const provider = getDataProvider();
-    isExporting = true;
+  async function triggerExport() {
+    const provider = getDataProviderForResource(resource, options.dataProviderName);
+    isLoading = true;
 
     try {
-      // Fetch all records (up to 10000)
-      const result: GetListResult = await provider.getList({
-        resource,
-        pagination: { current: 1, pageSize: 10000 },
-      });
-
-      if (result.data.length === 0) return;
-
-      const records = result.data as Record<string, unknown>[];
-      const fields = opts?.fields ?? Object.keys(records[0]);
-
-      // Build CSV
-      const header = fields.join(',');
-      const rows = records.map(record =>
-        fields.map(f => {
-          const val = record[f];
-          const str = val === null || val === undefined ? '' : String(val);
-          // Escape commas and quotes
-          return str.includes(',') || str.includes('"') || str.includes('\n')
-            ? `"${str.replace(/"/g, '""')}"`
-            : str;
-        }).join(',')
-      );
-
-      const csv = [header, ...rows].join('\n');
-      const blob = new Blob(['\uFEFF' + csv], { type: 'text/csv;charset=utf-8;' });
-      const url = URL.createObjectURL(blob);
-      const a = document.createElement('a');
-      a.href = url;
-      a.download = opts?.filename ?? `${resource}_export.csv`;
-      a.click();
-      URL.revokeObjectURL(url);
+      const batchSize = options.pageSize ?? 20;
+      const maxItems = options.maxItemCount ?? Infinity;
+      let allRecords: TData[] = [];
+      let page = 1;
+
+      while (allRecords.length < maxItems) {
+        const result = await provider.getList<TData>({
+          resource,
+          pagination: { current: page, pageSize: batchSize },
+          sorters: options.sorters,
+          filters: options.filters,
+          meta: options.meta,
+        });
+
+        allRecords = [...allRecords, ...result.data];
+        if (result.data.length < batchSize || allRecords.length >= result.total) break;
+        page++;
+      }
+
+      if (maxItems !== Infinity) allRecords = allRecords.slice(0, maxItems);
+      if (allRecords.length === 0) return allRecords;
+
+      const mapped = options.mapData
+        ? allRecords.map(options.mapData)
+        : allRecords.map(r => r as unknown as Record<string, unknown>);
+
+      if (options.download !== false) {
+        const fields = Object.keys(mapped[0]);
+        const header = fields.join(',');
+        const rows = mapped.map(record =>
+          fields.map(f => {
+            const val = record[f];
+            const str = val === null || val === undefined ? '' : String(val);
+            return str.includes(',') || str.includes('"') || str.includes('\n')
+              ? `"${str.replace(/"/g, '""')}"`
+              : str;
+          }).join(',')
+        );
+
+        const csv = [header, ...rows].join('\n');
+        const blob = new Blob(['\uFEFF' + csv], { type: 'text/csv;charset=utf-8;' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = `${resource}_export.csv`;
+        a.click();
+        URL.revokeObjectURL(url);
+      }
+
+      return allRecords;
+    } catch (error) {
+      options.onError?.(error as Error);
+      return [];
     } finally {
-      isExporting = false;
+      isLoading = false;
     }
   }
 
   return {
-    exportCSV,
-    get isExporting() { return isExporting; },
+    triggerExport,
+    get isLoading() { return isLoading; },
   };
 }
 
+export interface UseImportOptions<TData = Record<string, unknown>> {
+  resource?: string;
+  mapData?: (item: Record<string, unknown>) => TData;
+  batchSize?: number;
+  onFinish?: (result: { succeeded: unknown[]; errored: { request: unknown; error: unknown }[] }) => void;
+  onProgress?: (info: { totalAmount: number; processedAmount: number }) => void;
+  meta?: Record<string, unknown>;
+  dataProviderName?: string;
+}
+
 /**
  * useImport — import records from a CSV file
+ * Supports mapData, batchSize, onFinish, onProgress, meta
  */
-export function useImport(resource: string) {
-  let isImporting = $state(false);
-  let importResult = $state<{ success: number; failed: number } | null>(null);
-
-  async function importCSV(file: File): Promise<{ success: number; failed: number }> {
-    const provider = getDataProvider();
-    isImporting = true;
-    let success = 0;
-    let failed = 0;
+export function useImport<TData = Record<string, unknown>>(options: UseImportOptions<TData> = {}) {
+  const parsed = useParsed();
+  const resource = options.resource ?? parsed.resource ?? '';
+  let isLoading = $state(false);
+  let mutationResult = $state<{ succeeded: unknown[]; errored: { request: unknown; error: unknown }[] } | null>(null);
+
+  async function handleChange(info: { file: File }) {
+    const provider = getDataProviderForResource(resource, options.dataProviderName);
+    isLoading = true;
+    const succeeded: unknown[] = [];
+    const errored: { request: unknown; error: unknown }[] = [];
 
     try {
-      const text = await file.text();
+      const text = await info.file.text();
       const lines = text.split('\n').filter(l => l.trim() !== '');
-      if (lines.length < 2) return { success: 0, failed: 0 };
+      if (lines.length < 2) return;
 
       const headers = parseCSVLine(lines[0]);
+      const records: Record<string, unknown>[] = [];
 
       for (let i = 1; i < lines.length; i++) {
         const values = parseCSVLine(lines[i]);
         const record: Record<string, unknown> = {};
-        headers.forEach((h, idx) => {
-          record[h] = values[idx] ?? '';
-        });
+        headers.forEach((h, idx) => { record[h] = values[idx] ?? ''; });
+        records.push(options.mapData ? (options.mapData(record) as unknown as Record<string, unknown>) : record);
+      }
 
-        try {
-          await provider.create({ resource, variables: record });
-          success++;
-        } catch {
-          failed++;
+      const batchSize = options.batchSize ?? 1;
+      let processed = 0;
+
+      if (batchSize === 1) {
+        for (const record of records) {
+          try {
+            const res = await provider.create({ resource, variables: record, meta: options.meta });
+            succeeded.push(res);
+          } catch (error) {
+            errored.push({ request: record, error });
+          }
+          processed++;
+          options.onProgress?.({ totalAmount: records.length, processedAmount: processed });
+        }
+      } else {
+        for (let i = 0; i < records.length; i += batchSize) {
+          const batch = records.slice(i, i + batchSize);
+          try {
+            if (provider.createMany) {
+              const res = await provider.createMany({ resource, variables: batch, meta: options.meta });
+              succeeded.push(res);
+            } else {
+              for (const record of batch) {
+                const res = await provider.create({ resource, variables: record, meta: options.meta });
+                succeeded.push(res);
+              }
+            }
+          } catch (error) {
+            errored.push({ request: batch, error });
+          }
+          processed += batch.length;
+          options.onProgress?.({ totalAmount: records.length, processedAmount: processed });
         }
       }
 
-      importResult = { success, failed };
-      return { success, failed };
+      mutationResult = { succeeded, errored };
+      options.onFinish?.({ succeeded, errored });
     } finally {
-      isImporting = false;
+      isLoading = false;
     }
   }
 
   return {
-    importCSV,
-    get isImporting() { return isImporting; },
-    get importResult() { return importResult; },
+    inputProps: { type: 'file' as const, accept: '.csv' },
+    handleChange,
+    get isLoading() { return isLoading; },
+    get mutationResult() { return mutationResult; },
   };
 }