@svadmin/core 0.0.2 → 0.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/core",
-  "version": "0.0.2",
+  "version": "0.0.6",
   "description": "Core SDK — hooks, types, context, i18n, permissions, router",
   "type": "module",
   "sideEffects": false,

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/context.ts

@@ -2,10 +2,12 @@
 
 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');
 
 // ─── Setters (called once in App.svelte) ────────────────────────
 
@@ -47,3 +49,13 @@ export function getResource(name: string): ResourceDefinition {
   if (!resource) throw new Error(`Resource "${name}" not found in resource definitions.`);
   return resource;
 }
+
+// ─── Router Provider ────────────────────────────────────────────
+
+export function setRouterProvider(provider: RouterProvider): void {
+  setContext(ROUTER_PROVIDER_KEY, provider);
+}
+
+export function getRouterProvider(): RouterProvider | undefined {
+  return getContext<RouterProvider>(ROUTER_PROVIDER_KEY);
+}

package/src/data-transfer.test.ts

@@ -0,0 +1,118 @@
+// Unit tests for CSV parsing and data-transfer utilities
+import { describe, test, expect } from 'bun:test';
+
+// We test parseCSVLine directly by re-implementing the exported logic
+// since the function is not exported. We test the CSV format contract.
+
+function parseCSVLine(line: string): string[] {
+  const result: string[] = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (ch === '"') {
+        inQuotes = false;
+      } else {
+        current += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === ',') {
+        result.push(current.trim());
+        current = '';
+      } else {
+        current += ch;
+      }
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+
+describe('parseCSVLine', () => {
+  test('simple comma-separated values', () => {
+    expect(parseCSVLine('a,b,c')).toEqual(['a', 'b', 'c']);
+  });
+
+  test('values with whitespace are trimmed', () => {
+    expect(parseCSVLine(' hello , world , test ')).toEqual(['hello', 'world', 'test']);
+  });
+
+  test('quoted values preserve commas', () => {
+    expect(parseCSVLine('"hello, world",b,c')).toEqual(['hello, world', 'b', 'c']);
+  });
+
+  test('escaped quotes inside quoted values', () => {
+    expect(parseCSVLine('"say ""hello""",b')).toEqual(['say "hello"', 'b']);
+  });
+
+  test('empty values', () => {
+    expect(parseCSVLine('a,,c')).toEqual(['a', '', 'c']);
+  });
+
+  test('single value', () => {
+    expect(parseCSVLine('hello')).toEqual(['hello']);
+  });
+
+  test('empty line', () => {
+    expect(parseCSVLine('')).toEqual(['']);
+  });
+
+  test('quoted value with newline character', () => {
+    expect(parseCSVLine('"line1\nline2",b')).toEqual(['line1\nline2', 'b']);
+  });
+
+  test('mixed quoted and unquoted', () => {
+    expect(parseCSVLine('1,"John Doe","admin@test.com",true')).toEqual([
+      '1', 'John Doe', 'admin@test.com', 'true'
+    ]);
+  });
+});
+
+// CSV row formatting (escape logic from useExport)
+function escapeCSVField(val: unknown): string {
+  const str = val === null || val === undefined ? '' : String(val);
+  return str.includes(',') || str.includes('"') || str.includes('\n')
+    ? `"${str.replace(/"/g, '""')}"`
+    : str;
+}
+
+describe('escapeCSVField', () => {
+  test('simple string passes through', () => {
+    expect(escapeCSVField('hello')).toBe('hello');
+  });
+
+  test('null becomes empty string', () => {
+    expect(escapeCSVField(null)).toBe('');
+  });
+
+  test('undefined becomes empty string', () => {
+    expect(escapeCSVField(undefined)).toBe('');
+  });
+
+  test('string with comma is quoted', () => {
+    expect(escapeCSVField('hello, world')).toBe('"hello, world"');
+  });
+
+  test('string with double quote is escaped', () => {
+    expect(escapeCSVField('say "hi"')).toBe('"say ""hi"""');
+  });
+
+  test('string with newline is quoted', () => {
+    expect(escapeCSVField('line1\nline2')).toBe('"line1\nline2"');
+  });
+
+  test('number is converted to string', () => {
+    expect(escapeCSVField(42)).toBe('42');
+  });
+
+  test('boolean is converted to string', () => {
+    expect(escapeCSVField(true)).toBe('true');
+  });
+});

package/src/data-transfer.ts

@@ -0,0 +1,139 @@
+// Data transfer utilities — CSV export/import
+
+import { getDataProvider } from './context';
+import type { GetListResult } from './types';
+
+/**
+ * useExport — export all records from a resource as CSV download
+ */
+export function useExport(resource: string) {
+  let isExporting = $state(false);
+
+  async function exportCSV(opts?: { filename?: string; fields?: string[] }) {
+    const provider = getDataProvider();
+    isExporting = 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);
+    } finally {
+      isExporting = false;
+    }
+  }
+
+  return {
+    exportCSV,
+    get isExporting() { return isExporting; },
+  };
+}
+
+/**
+ * useImport — import records from a CSV file
+ */
+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;
+
+    try {
+      const text = await file.text();
+      const lines = text.split('\n').filter(l => l.trim() !== '');
+      if (lines.length < 2) return { success: 0, failed: 0 };
+
+      const headers = parseCSVLine(lines[0]);
+
+      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] ?? '';
+        });
+
+        try {
+          await provider.create({ resource, variables: record });
+          success++;
+        } catch {
+          failed++;
+        }
+      }
+
+      importResult = { success, failed };
+      return { success, failed };
+    } finally {
+      isImporting = false;
+    }
+  }
+
+  return {
+    importCSV,
+    get isImporting() { return isImporting; },
+    get importResult() { return importResult; },
+  };
+}
+
+/** Parse a single CSV line respecting quoted fields */
+function parseCSVLine(line: string): string[] {
+  const result: string[] = [];
+  let current = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (inQuotes) {
+      if (ch === '"' && line[i + 1] === '"') {
+        current += '"';
+        i++;
+      } else if (ch === '"') {
+        inQuotes = false;
+      } else {
+        current += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === ',') {
+        result.push(current.trim());
+        current = '';
+      } else {
+        current += ch;
+      }
+    }
+  }
+  result.push(current.trim());
+  return result;
+}