@svadmin/core 0.25.2 → 0.25.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@svadmin/core",
-  "version": "0.25.2",
+  "version": "0.25.4",
   "author": "zuohuadong",
   "repository": {
     "type": "git",
@@ -22,7 +22,7 @@
   },
   "peerDependencies": {
     "svelte": "^5.0.0",
-    "@tanstack/svelte-query": "^6.0.0"
+    "@tanstack/svelte-query": "^6.1.29"
   },
   "exports": {
     ".": {
@@ -63,7 +63,11 @@
   },
   "description": "Core SDK — hooks, types, context, i18n, permissions, router",
   "files": [
-    "src/**/*"
+    "src/**/*.ts",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*",
+    "!src/**/vitest.config.*",
+    "!src/**/setupTest.*"
   ],
   "homepage": "https://github.com/zuohuadong/svadmin#readme",
   "license": "MIT",

package/src/README.md

@@ -1,18 +0,0 @@
-# Name
-### {{module_name}}
-
-# Synopsis
-{{synopsis}}
-
-# Description
-
-# Example
-
-# Install:
-`npm install {{module_name}}`
-
-# Test:
-`npm test`
-
-#License:
-{{license}}

package/src/auth-hooks.test.ts

@@ -1,205 +0,0 @@
-/**
- * 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/chatProvider.test.ts

@@ -1,388 +0,0 @@
-// Unit tests for ChatProvider types and ChatContext logic
-// Since chatProvider.svelte.ts uses $state runes (requires Svelte compiler),
-// we test the pure type shapes and serialization here — matching the project's
-// pattern in i18n.test.ts of testing extracted logic.
-
-import { describe, test, expect } from 'bun:test';
-
-/** Mirror of ChatAction from chatProvider.svelte.ts */
-interface ChatAction {
-  label: string;
-  variant?: 'default' | 'destructive' | 'outline';
-  payload?: Record<string, unknown>;
-}
-
-/** Mirror of ChatMessage from chatProvider.svelte.ts */
-interface ChatMessage {
-  id: string;
-  role: 'user' | 'assistant' | 'system';
-  content: string;
-  timestamp: number;
-  actions?: ChatAction[];
-}
-
-/** Mirror of ChatContext from chatProvider.svelte.ts */
-interface ChatContext {
-  currentResource?: string;
-  selectedRecordId?: string;
-  currentView?: 'list' | 'edit' | 'create' | 'show';
-  pathname?: string;
-}
-
-/** Build context system message (mirrors logic in ChatDialog.svelte) */
-function buildContextSystemMessage(ctx: ChatContext): ChatMessage | null {
-  if (!ctx.currentResource) return null;
-
-  const parts: string[] = [];
-  parts.push(`Resource: ${ctx.currentResource}`);
-  if (ctx.currentView) parts.push(`View: ${ctx.currentView}`);
-  if (ctx.selectedRecordId) parts.push(`Selected Record ID: ${ctx.selectedRecordId}`);
-  if (ctx.pathname) parts.push(`Path: ${ctx.pathname}`);
-
-  return {
-    id: 'ctx-system',
-    role: 'system',
-    content: `[Admin Context] ${parts.join(' | ')}`,
-    timestamp: Date.now(),
-  };
-}
-
-describe('ChatMessage with actions', () => {
-  test('message with actions serializes to JSON and back', () => {
-    const actions: ChatAction[] = [
-      { label: 'Delete Record', variant: 'destructive', payload: { id: '42' } },
-      { label: 'View Details' },
-    ];
-    const msg: ChatMessage = {
-      id: 'msg-1',
-      role: 'assistant',
-      content: 'I found a record to delete.',
-      timestamp: 1711500000000,
-      actions,
-    };
-
-    const serialized = JSON.stringify(msg);
-    const deserialized = JSON.parse(serialized) as ChatMessage;
-
-    expect(deserialized.actions).toHaveLength(2);
-    expect(deserialized.actions![0].label).toBe('Delete Record');
-    expect(deserialized.actions![0].variant).toBe('destructive');
-    expect(deserialized.actions![0].payload).toEqual({ id: '42' });
-    expect(deserialized.actions![1].variant).toBeUndefined();
-  });
-
-  test('message without actions has undefined actions', () => {
-    const msg: ChatMessage = {
-      id: 'msg-2',
-      role: 'user',
-      content: 'Hello',
-      timestamp: 1711500000000,
-    };
-    expect(msg.actions).toBeUndefined();
-  });
-
-  test('system message persists correctly', () => {
-    const msg: ChatMessage = {
-      id: 'ctx-1',
-      role: 'system',
-      content: '[Admin Context] Resource: posts | View: edit',
-      timestamp: 1711500000000,
-    };
-    const parsed = JSON.parse(JSON.stringify(msg)) as ChatMessage;
-    expect(parsed.role).toBe('system');
-    expect(parsed.content).toContain('posts');
-  });
-});
-
-describe('buildContextSystemMessage', () => {
-  test('returns null when no resource', () => {
-    expect(buildContextSystemMessage({})).toBeNull();
-  });
-
-  test('builds message with resource only', () => {
-    const msg = buildContextSystemMessage({ currentResource: 'users' });
-    expect(msg).not.toBeNull();
-    expect(msg!.role).toBe('system');
-    expect(msg!.content).toContain('Resource: users');
-  });
-
-  test('includes all context fields', () => {
-    const msg = buildContextSystemMessage({
-      currentResource: 'posts',
-      currentView: 'edit',
-      selectedRecordId: '42',
-      pathname: '/posts/edit/42',
-    });
-    expect(msg!.content).toContain('Resource: posts');
-    expect(msg!.content).toContain('View: edit');
-    expect(msg!.content).toContain('Selected Record ID: 42');
-    expect(msg!.content).toContain('Path: /posts/edit/42');
-  });
-
-  test('omits undefined fields', () => {
-    const msg = buildContextSystemMessage({
-      currentResource: 'users',
-      currentView: 'list',
-    });
-    expect(msg!.content).not.toContain('Selected Record ID');
-    expect(msg!.content).not.toContain('Path');
-  });
-});
-
-describe('ChatContext shape', () => {
-  test('empty context is valid', () => {
-    const ctx: ChatContext = {};
-    expect(ctx.currentResource).toBeUndefined();
-  });
-
-  test('full context preserves all fields', () => {
-    const ctx: ChatContext = {
-      currentResource: 'orders',
-      selectedRecordId: '99',
-      currentView: 'show',
-      pathname: '/orders/show/99',
-    };
-    expect(ctx.currentResource).toBe('orders');
-    expect(ctx.selectedRecordId).toBe('99');
-    expect(ctx.currentView).toBe('show');
-    expect(ctx.pathname).toBe('/orders/show/99');
-  });
-});
-
-describe('localStorage persistence simulation', () => {
-  test('messages array round-trips through JSON', () => {
-    const messages: ChatMessage[] = [
-      { id: '1', role: 'user', content: 'Hello', timestamp: 1000 },
-      {
-        id: '2', role: 'assistant', content: 'Hi!', timestamp: 1001,
-        actions: [{ label: 'Create Post', variant: 'default', payload: { resource: 'posts' } }],
-      },
-    ];
-    const json = JSON.stringify(messages);
-    const restored = JSON.parse(json) as ChatMessage[];
-
-    expect(restored).toHaveLength(2);
-    expect(restored[0].role).toBe('user');
-    expect(restored[1].actions![0].label).toBe('Create Post');
-  });
-});
-
-// ─── AgentProvider Types ───────────────────────────────────────
-
-/** Mirror of AdminToolParameter from chatProvider.svelte.ts */
-interface AdminToolParameter {
-  type: 'string' | 'number' | 'boolean' | 'object' | 'array';
-  description?: string;
-  enum?: string[];
-  required?: boolean;
-}
-
-/** Mirror of AdminTool from chatProvider.svelte.ts */
-interface AdminTool {
-  name: string;
-  description: string;
-  parameters: Record<string, AdminToolParameter>;
-  needsApproval?: boolean;
-  execute(args: Record<string, unknown>): Promise<{ success: boolean; data?: unknown; error?: string }>;
-}
-
-/** Mirror of AgentEvent from chatProvider.svelte.ts */
-type AgentEvent =
-  | { type: 'text'; content: string }
-  | { type: 'tool_call'; tool: string; args: Record<string, unknown> }
-  | { type: 'approval_request'; id: string; tool: string; args: Record<string, unknown>; description: string }
-  | { type: 'tool_result'; tool: string; result: { success: boolean; data?: unknown; error?: string } }
-  | { type: 'component'; name: string; props: Record<string, unknown> }
-  | { type: 'done' };
-
-describe('AdminTool shape', () => {
-  test('tool with needsApproval serializes correctly', () => {
-    const tool: AdminTool = {
-      name: 'deletePosts',
-      description: 'Delete posts matching a filter',
-      parameters: {
-        status: { type: 'string', description: 'Filter by status', enum: ['draft', 'archived'] },
-      },
-      needsApproval: true,
-      execute: async (args) => ({ success: true, data: { deleted: args.ids } }),
-    };
-
-    expect(tool.name).toBe('deletePosts');
-    expect(tool.needsApproval).toBe(true);
-    expect(tool.parameters.status.enum).toEqual(['draft', 'archived']);
-  });
-
-  test('tool without approval defaults to undefined', () => {
-    const tool: AdminTool = {
-      name: 'getStats',
-      description: 'Fetch dashboard statistics',
-      parameters: {},
-      execute: async () => ({ success: true, data: { users: 100 } }),
-    };
-
-    expect(tool.needsApproval).toBeUndefined();
-  });
-
-  test('tool execute returns ToolResult', async () => {
-    const tool: AdminTool = {
-      name: 'createPost',
-      description: 'Create a new post',
-      parameters: {
-        title: { type: 'string', required: true },
-      },
-      execute: async (args) => ({
-        success: true,
-        data: { id: '1', title: args.title },
-      }),
-    };
-
-    const result = await tool.execute({ title: 'Hello World' });
-    expect(result.success).toBe(true);
-    expect(result.data).toEqual({ id: '1', title: 'Hello World' });
-  });
-
-  test('tool execute can return error', async () => {
-    const tool: AdminTool = {
-      name: 'failingTool',
-      description: 'A tool that fails',
-      parameters: {},
-      execute: async () => ({
-        success: false,
-        error: 'Permission denied',
-      }),
-    };
-
-    const result = await tool.execute({});
-    expect(result.success).toBe(false);
-    expect(result.error).toBe('Permission denied');
-  });
-});
-
-describe('AgentEvent stream', () => {
-  test('events can be collected from async generator', async () => {
-    async function* mockAgent(): AsyncGenerator<AgentEvent, void, unknown> {
-      yield { type: 'text', content: 'Searching...' };
-      yield { type: 'tool_call', tool: 'getList', args: { resource: 'posts' } };
-      yield { type: 'tool_result', tool: 'getList', result: { success: true, data: [{ id: 1 }] } };
-      yield { type: 'text', content: 'Found 1 post.' };
-      yield { type: 'done' };
-    }
-
-    const events: AgentEvent[] = [];
-    for await (const event of mockAgent()) {
-      events.push(event);
-    }
-
-    expect(events).toHaveLength(5);
-    expect(events[0].type).toBe('text');
-    expect(events[1].type).toBe('tool_call');
-    expect(events[2].type).toBe('tool_result');
-    expect(events[4].type).toBe('done');
-  });
-
-  test('approval_request event serializes correctly', () => {
-    const event: AgentEvent = {
-      type: 'approval_request',
-      id: 'req-42',
-      tool: 'deletePosts',
-      args: { ids: ['1', '2', '3'] },
-      description: 'Delete 3 draft posts',
-    };
-
-    const serialized = JSON.stringify(event);
-    const parsed = JSON.parse(serialized) as AgentEvent;
-
-    expect(parsed.type).toBe('approval_request');
-    if (parsed.type === 'approval_request') {
-      expect(parsed.id).toBe('req-42');
-      expect(parsed.tool).toBe('deletePosts');
-      expect(parsed.description).toBe('Delete 3 draft posts');
-    }
-  });
-
-  test('component event carries name and props', () => {
-    const event: AgentEvent = {
-      type: 'component',
-      name: 'SalesChart',
-      props: { period: 'monthly', data: [100, 200, 150] },
-    };
-
-    expect(event.type).toBe('component');
-    if (event.type === 'component') {
-      expect(event.name).toBe('SalesChart');
-      expect(event.props.period).toBe('monthly');
-    }
-  });
-});
-
-describe('Approval flow', () => {
-  test('registerApproval and resolveApproval work together', () => {
-    // Simulate the approval flow without importing rune-based module
-    const pending = new Map<string, (approved: boolean) => void>();
-
-    function register(id: string, cb: (approved: boolean) => void) {
-      pending.set(id, cb);
-    }
-
-    function resolve(id: string, approved: boolean): boolean {
-      const cb = pending.get(id);
-      if (!cb) return false;
-      cb(approved);
-      pending.delete(id);
-      return true;
-    }
-
-    let approvalResult = false;
-
-    register('req-1', (approved) => {
-      approvalResult = approved;
-    });
-
-    expect(pending.size).toBe(1);
-
-    // Resolve with approval
-    const resolved = resolve('req-1', true);
-    expect(resolved).toBe(true);
-    expect(approvalResult).toEqual(true);
-    expect(pending.size).toBe(0);
-  });
-
-  test('resolveApproval returns false for unknown id', () => {
-    const pending = new Map<string, (approved: boolean) => void>();
-
-    function resolve(id: string, approved: boolean): boolean {
-      const cb = pending.get(id);
-      if (!cb) return false;
-      cb(approved);
-      pending.delete(id);
-      return true;
-    }
-
-    expect(resolve('nonexistent', true)).toBe(false);
-  });
-
-  test('rejection flow works', () => {
-    const pending = new Map<string, (approved: boolean) => void>();
-
-    function register(id: string, cb: (approved: boolean) => void) {
-      pending.set(id, cb);
-    }
-
-    function resolve(id: string, approved: boolean): boolean {
-      const cb = pending.get(id);
-      if (!cb) return false;
-      cb(approved);
-      pending.delete(id);
-      return true;
-    }
-
-    let wasApproved = true;
-
-    register('req-2', (approved) => {
-      wasApproved = approved;
-    });
-
-    resolve('req-2', false);
-    expect(wasApproved).toEqual(false);
-  });
-});