@svadmin/core 0.22.0 → 0.23.0

package/src/form-hooks.svelte.ts

@@ -1,14 +1,17 @@
 import { useQueryClient } from '@tanstack/svelte-query';
 import { useParsed } from './useParsed.svelte';
 import { getAdminOptions } from './options.svelte';
-import { getDataProviderForResource, getResource } from './context.svelte';
+import { getDataProviderForResource, getResource, getLiveProvider } from './context.svelte';
 import { createQuery, createMutation } from '@tanstack/svelte-query';
 import { notify } from './notification.svelte';
 import { t } from './i18n.svelte';
 import { audit } from './audit';
 import { navigate, currentPath } from './router';
-import { HttpError } from './types';
+import { HttpError, UndoError } from './types';
 import type { BaseRecord, MutationMode, KnownResources } from './types';
+import { checkError } from './hook-utils.svelte';
+import { toast } from './toast.svelte';
+import { deepMerge, invalidateByScopes } from './mutation-hooks.svelte';
 
 // ─── Types ───────────────────────────────────────────────────────────
 
@@ -18,7 +21,7 @@ export interface UseFormOptions<
   TError = HttpError,
 > {
   resource?: KnownResources;
-  action?: 'create' | 'edit' | 'clone';
+  action?: 'create' | 'edit' | 'clone' | 'show';
   id?: string | number;
   redirect?: 'list' | 'edit' | 'show' | false;
 
@@ -41,7 +44,7 @@ export interface UseFormOptions<
   /** Called every time a field value changes. */
   onChange?: (event: { field: string; value: unknown; values: TVariables }) => void;
   /** Called before mutation. Return false or call cancel() to prevent submission. */
-  onSubmit?: (ctx: { values: TVariables; action: 'create' | 'edit' | 'clone'; cancel: () => void }) => void | boolean;
+  onSubmit?: (ctx: { values: TVariables; action: 'create' | 'edit' | 'clone' | 'show'; cancel: () => void }) => void | boolean;
 
   // ─── Meta ─────────────────────────────────────────────────────
   meta?: Record<string, unknown>;
@@ -95,6 +98,7 @@ export interface UseFormReturn<
   // ─── Tainted (dirty) ──────────────────────────────────────────
   readonly tainted: Record<string, boolean>;
   isTainted: (field?: string) => boolean;
+  untaint: () => void;
 
   // ─── Errors ───────────────────────────────────────────────────
   readonly errors: Record<string, string>;
@@ -113,12 +117,12 @@ export interface UseFormReturn<
   // ─── State ──────────────────────────────────────────────────────
   readonly loading: boolean;
   readonly submitting: boolean;
-  readonly action: 'create' | 'edit' | 'clone';
+  readonly action: 'create' | 'edit' | 'clone' | 'show';
   readonly resource: string;
   readonly id: string | number | undefined;
   readonly isDirty: boolean;
   setId: (id: string | number | undefined) => void;
-  setAction: (action: 'create' | 'edit' | 'clone') => void;
+  setAction: (action: 'create' | 'edit' | 'clone' | 'show') => void;
   mutationMode: MutationMode;
   redirect: (to: 'list' | 'edit' | 'show' | false) => void;
 
@@ -143,7 +147,7 @@ export function useForm<
   const adminOptions = getAdminOptions();
 
   const resource = $derived(options.resource ?? parsed.resource ?? '');
-  let action = $state<'create' | 'edit' | 'clone'>(options.action ?? (parsed.action === 'list' ? 'create' : parsed.action as 'create' | 'edit' | 'clone') ?? 'create');
+  let action = $state<'create' | 'edit' | 'clone' | 'show'>(options.action ?? (parsed.action === 'list' ? 'create' : parsed.action as 'create' | 'edit' | 'clone' | 'show') ?? 'create');
   let currentId = $state<string | number | undefined>(options.id ?? parsed.id);
 
   const defaultRedirectOpt = $derived(action === 'clone' ? adminOptions.redirect?.afterClone : action === 'edit' ? adminOptions.redirect?.afterEdit : adminOptions.redirect?.afterCreate);
@@ -166,12 +170,11 @@ export function useForm<
   const redirectDefault = $derived(redirectOption ?? defaultRedirectOpt ?? 'list');
 
   const provider = $derived(getDataProviderForResource(resource, dataProviderName));
-  const parsedMeta = useParsed().params || {};
-  const queryMeta = { ...parsedMeta, ...hookMeta, ...hookQueryMeta };
-  const mutationMeta = { ...parsedMeta, ...hookMeta, ...hookMutationMeta };
+  const queryMeta = $derived({ ...useParsed().params, ...hookMeta, ...hookQueryMeta });
+  const mutationMeta = $derived({ ...useParsed().params, ...hookMeta, ...hookMutationMeta });
 
   function setId(newId: string | number | undefined) { currentId = newId; }
-  function setAction(newAction: 'create' | 'edit' | 'clone') { action = newAction; }
+  function setAction(newAction: 'create' | 'edit' | 'clone' | 'show') { action = newAction; }
 
   // ─── Form values (single source of truth) ───────────────────────
   let values = $state<TVariables>((options.defaultValues ?? {}) as TVariables);
@@ -243,10 +246,13 @@ export function useForm<
     values = { ...initialValues } as TVariables;
     tainted = {};
     clearErrors();
+    queryInitializedId = undefined;
   }
 
   // ─── Server error handling ──────────────────────────────────────
+
   function handleHttpError(error: Error) {
+    checkError(error);
     if (error instanceof HttpError && error.errors && !disableServerSideValidation) {
       for (const [field, messages] of Object.entries(error.errors)) {
         const msg = Array.isArray(messages) ? messages[0] : messages;
@@ -262,12 +268,12 @@ export function useForm<
   // Always create the query — use `enabled` to conditionally activate.
   // This ensures setAction('edit') at runtime will trigger a fetch.
   const query = createQuery(() => ({
-    queryKey: [resource, 'one', currentId],
+    queryKey: [options.dataProviderName, resource, 'one', currentId, queryMeta],
     queryFn: async () => {
       const result = await provider.getOne<BaseRecord>({ resource, id: currentId!, meta: queryMeta });
-      return result.data;
+      return result;
     },
-    enabled: (queryOptions?.enabled ?? true) && (action === 'edit' || action === 'clone') && currentId != null,
+    enabled: (queryOptions?.enabled ?? true) && (action === 'edit' || action === 'clone' || action === 'show') && currentId != null,
     staleTime: queryOptions?.staleTime,
   }));
 
@@ -275,14 +281,24 @@ export function useForm<
   let queryInitializedId: string | number | undefined = undefined;
   {
     $effect.pre(() => {
+      // Discard previous fetch lock and default when switched strictly back to create
+      if (action === 'create' && queryInitializedId !== undefined) {
+        queryInitializedId = undefined;
+        const def = (options.defaultValues ?? {}) as TVariables;
+        values = { ...def };
+        initialValues = { ...def };
+        tainted = {};
+        clearErrors();
+        return;
+      }
       if (queryInitializedId === currentId) return;
-      const data = query.data as Record<string, unknown> | undefined;
+      const record = (query.data as { data: Record<string, unknown> } | undefined)?.data;
       const pk = getResource(resource).primaryKey ?? 'id';
-      if (data && (currentId == null || String(data[pk]) === String(currentId) || !data[pk])) {
-        // In clone mode, strip out identifiers
+      if (record && String(record[pk]) === String(currentId)) {
+        const cloneStripKeys = new Set(['id', '_id', pk, 'createdAt', 'updatedAt', 'created_at', 'updated_at', 'createdBy', 'updated_by', 'created_by', 'updatedBy']);
         const targetData = action === 'clone' 
-          ? Object.fromEntries(Object.entries(data).filter(([k]) => k !== 'id' && k !== '_id' && k !== pk))
-          : data;
+          ? Object.fromEntries(Object.entries(record).filter(([k]) => !cloneStripKeys.has(k)))
+          : record;
         // Merge: defaultValues < query data
         const merged = { ...(options.defaultValues ?? {}), ...targetData } as TVariables;
         values = merged;
@@ -299,13 +315,18 @@ export function useForm<
     ...options.createMutationOptions,
     mutationFn: (variables: TVariables) => provider.create<TData, TVariables>({ resource, variables, meta: mutationMeta }),
     onSuccess: (data: { data: TData }) => {
-      if (invalidateScopes !== false) queryClient.invalidateQueries({ queryKey: [resource] });
+      invalidateByScopes(queryClient, resource, invalidateScopes, ['list', 'many']);
       if (successNotification !== false) notify({ type: 'success', message: typeof successNotification === 'string' ? successNotification : t('common.createSuccess') });
       const pk = getResource(resource).primaryKey ?? 'id';
-      audit({ action: 'create', resource, recordId: String((data.data as Record<string, unknown>)[pk]) });
+      const newId = (data.data as Record<string, unknown>)[pk];
+      audit({ action: 'create', resource, recordId: String(newId) });
+      // Publish live event
+      try {
+        const lp = getLiveProvider();
+        if (lp?.publish) lp.publish({ type: 'INSERT', resource, payload: { ids: newId != null ? [newId as string | number] : [] } });
+      } catch { /* no live provider */ }
       onMutationSuccess?.(data);
       if (redirectOverride !== false) {
-        const newId = (data.data as Record<string, unknown>)[pk];
         if (newId != null) currentId = newId as string | number;
         doRedirect(redirectOverride ?? redirectDefault);
       }
@@ -313,17 +334,60 @@ export function useForm<
     onError: (error: Error) => { handleHttpError(error); onMutationError?.(error); },
   }));
 
-  const updateMut = createMutation(() => ({
+  const updateMut = createMutation<{ data: TData }, unknown, TVariables>(() => ({
     ...options.updateMutationOptions,
-    mutationFn: (variables: TVariables) => provider.update<TData, TVariables>({ resource, id: currentId!, variables, meta: mutationMeta }),
-    onSuccess: (data: { data: TData }) => {
-      if (invalidateScopes !== false) queryClient.invalidateQueries({ queryKey: [resource] });
+    mutationFn: async (variables: TVariables) => {
+      if (mutationMode === 'undoable') {
+        await new Promise<void>((resolve, reject) => {
+          toast.undoable(t('common.actionCanBeUndone'), undoableTimeout, () => {
+            reject(new UndoError());
+          }, resolve);
+        });
+      }
+      return provider.update<TData, TVariables>({ resource, id: currentId!, variables, meta: mutationMeta });
+    },
+    onMutate: async (variables: TVariables) => {
+      if (mutationMode === 'pessimistic') return;
+      await queryClient.cancelQueries({ predicate: (q) => q.queryKey[1] === resource });
+      const previousQueries = queryClient.getQueriesData({ predicate: (q) => q.queryKey[1] === resource });
+      if (optimisticUpdateMap?.list !== false) {
+        queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resource && q.queryKey[2] === 'list' }, (old: unknown) => {
+          if (!old || typeof old !== 'object' || !('data' in old)) return old;
+          const o = old as { data: Record<string, unknown>[] };
+          const pk = getResource(resource).primaryKey ?? 'id';
+          return { ...o, data: o.data.map((item) => String(item[pk]) === String(currentId) ? deepMerge(item, variables) : item) };
+        });
+      }
+      if (optimisticUpdateMap?.detail !== false && currentId != null) {
+        queryClient.setQueriesData({ predicate: (q) => q.queryKey[1] === resource && q.queryKey[2] === 'one' && q.queryKey[3] === currentId }, (old: Record<string, unknown> | undefined) => old ? { ...old, data: deepMerge((old as Record<string, unknown>).data || {}, variables) } : old);
+      }
+      return { previousQueries };
+    },
+    onSuccess: (data: unknown) => {
       if (successNotification !== false) notify({ type: 'success', message: typeof successNotification === 'string' ? successNotification : t('common.updateSuccess') });
       audit({ action: 'update', resource, recordId: String(currentId) });
+      try {
+        const lp = getLiveProvider();
+        if (lp?.publish) lp.publish({ type: 'UPDATE', resource, payload: { ids: currentId != null ? [currentId] : [] } });
+      } catch { /* no live provider */ }
       onMutationSuccess?.(data);
       if (redirectOverride !== false) doRedirect(redirectOverride ?? redirectDefault);
     },
-    onError: (error: Error) => { handleHttpError(error); onMutationError?.(error); },
+    onSettled: (_data: unknown, error: unknown) => {
+      if (error instanceof UndoError) return;
+      invalidateByScopes(queryClient, resource, invalidateScopes, ['list', 'many', 'detail'], currentId ?? undefined);
+    },
+    onError: (error: unknown, _vars: unknown, context: unknown) => {
+      const ctx = context as { previousQueries?: [unknown, unknown][] } | undefined;
+      if (ctx?.previousQueries) {
+        for (const [queryKey, data] of ctx.previousQueries) {
+          queryClient.setQueryData(queryKey as string[], data);
+        }
+      }
+      if (error instanceof UndoError) return;
+      handleHttpError(error as Error);
+      onMutationError?.(error as Error);
+    },
   }));
 
   function doRedirect(to: 'list' | 'edit' | 'show' | false) {
@@ -339,7 +403,7 @@ export function useForm<
 
   // ─── Submit ─────────────────────────────────────────────────────
   async function submit(overrides?: { redirect?: 'list' | 'edit' | 'show' | false }) {
-    // onSubmit pre-hook
+    if (autoSaveTimer) { clearTimeout(autoSaveTimer); autoSaveTimer = null; }
     if (onSubmitFn) {
       let cancelled = false;
       const result = onSubmitFn({ values, action, cancel: () => { cancelled = true; } });
@@ -351,11 +415,9 @@ export function useForm<
     try {
       if (action === 'create' || action === 'clone') await createMut.mutateAsync(values);
       else await updateMut.mutateAsync(values);
-      // Untaint on success
       tainted = {};
-    } catch (error) {
-      // Errors are already handled by the mutation's onError callback.
-      // We catch here to prevent unhandled promise rejections.
+    } catch {
+      // Errors already handled by mutation's onError callback
     }
   }
 
@@ -365,36 +427,41 @@ export function useForm<
   let lastAutoSaveData = $state<unknown>(null);
   let lastAutoSaveError = $state<unknown>(null);
 
+  $effect(() => {
+    return () => {
+      if (autoSaveTimer) clearTimeout(autoSaveTimer);
+    };
+  });
+
   function triggerAutoSave() {
-    const currentAction = action; // read $state reactively at call time
-    if (!autoSaveOpts?.enabled || currentAction === 'create' || currentAction === 'clone') return;
+    const currentAction = action;
+    if (!autoSaveOpts?.enabled || currentAction === 'create' || currentAction === 'clone' || currentId == null) return;
+    if (createMut.isPending || updateMut.isPending) return;
     if (autoSaveTimer) clearTimeout(autoSaveTimer);
 
+    const safeId = currentId;
     autoSaveTimer = setTimeout(async () => {
       const finalValues = autoSaveOpts.onFinish ? autoSaveOpts.onFinish(values) : values;
       autoSaveStatus = 'saving';
       try {
-        await provider.update<TData, TVariables>({ resource, id: currentId!, variables: finalValues, meta: mutationMeta });
+        await provider.update<TData, TVariables>({ resource, id: safeId as string | number, variables: finalValues, meta: mutationMeta });
         const scopes = autoSaveOpts.invalidates ?? ['resourceAll'];
-        for (const scope of scopes) {
-          if (scope === 'resourceAll') queryClient.invalidateQueries({ queryKey: [resource] });
-          else if (scope === 'detail' && currentId) queryClient.invalidateQueries({ queryKey: [resource, 'one', currentId] });
-          else if (scope === 'list') queryClient.invalidateQueries({ queryKey: [resource, 'list'] });
-        }
+        invalidateByScopes(queryClient, resource, scopes, ['resourceAll'], safeId ?? undefined);
         autoSaveStatus = 'saved';
-        lastAutoSaveData = undefined;
+        lastAutoSaveData = finalValues;
         lastAutoSaveError = null;
         setTimeout(() => { autoSaveStatus = 'idle'; }, 2000);
       } catch (e) {
         autoSaveStatus = 'error';
         lastAutoSaveError = e;
+        checkError(e);
       }
     }, autoSaveOpts.debounce ?? 1000);
   }
 
   if (autoSaveOpts?.invalidateOnUnmount) {
     $effect(() => {
-      return () => queryClient.invalidateQueries({ queryKey: [resource] });
+      return () => queryClient.invalidateQueries({ predicate: (q) => q.queryKey[1] === resource });
     });
   }
 
@@ -422,6 +489,7 @@ export function useForm<
     // Tainted
     get tainted() { return tainted; },
     isTainted,
+    untaint: () => { tainted = {}; },
 
     // Errors
     get errors() { return errors; },

package/src/helpers-pure.ts

@@ -0,0 +1,159 @@
+// Pure utility functions — no Svelte runtime dependency
+// Extracted to enable unit testing with bun test
+
+import type { Filter, Sort, CrudOperator } from './types';
+
+// ─── Table Helpers ────────────────────────────────────────────
+
+/**
+ * Get the current filter value for a field from a filter array.
+ */
+export function getDefaultFilter(
+  columnName: string,
+  filters?: Filter[],
+  operatorType: CrudOperator = 'eq',
+): unknown | undefined {
+  if (!filters) return undefined;
+  const filter = filters.find((f) => {
+    if ('field' in f) {
+      return f.field === columnName && f.operator === operatorType;
+    }
+    return false;
+  });
+  return filter && 'value' in filter ? filter.value : undefined;
+}
+
+/**
+ * Get the current sort order for a field from a sorter array.
+ */
+export function getDefaultSortOrder(
+  columnName: string,
+  sorters?: Sort[],
+): 'asc' | 'desc' | undefined {
+  if (!sorters) return undefined;
+  const sortItem = sorters.find((item) => item.field === columnName);
+  return sortItem?.order as 'asc' | 'desc' | undefined;
+}
+
+/**
+ * Merge two filter arrays, deduplicating by field+operator.
+ */
+export function unionFilters(
+  permanentFilter: Filter[],
+  newFilters: Filter[],
+  prevFilters: Filter[] = [],
+): Filter[] {
+  const compareFilters = (a: Filter, b: Filter): boolean => {
+    if ('field' in a && 'field' in b) {
+      return a.field === b.field && a.operator === b.operator;
+    }
+    return false;
+  };
+
+  let result = [...prevFilters];
+
+  for (const newFilter of newFilters) {
+    const idx = result.findIndex((f) => compareFilters(f, newFilter));
+    if (idx >= 0) {
+      result[idx] = newFilter;
+    } else {
+      result.push(newFilter);
+    }
+  }
+
+  for (const perm of permanentFilter) {
+    const idx = result.findIndex((f) => compareFilters(f, perm));
+    if (idx >= 0) {
+      result[idx] = perm;
+    } else {
+      result.push(perm);
+    }
+  }
+
+  return result.filter((f) => !('value' in f && f.value === undefined));
+}
+
+/**
+ * Merge two sorter arrays, deduplicating by field.
+ */
+export function unionSorters(
+  permanentSorters: Sort[],
+  newSorters: Sort[],
+): Sort[] {
+  const result = [...newSorters];
+
+  for (const perm of permanentSorters) {
+    if (!result.some((s) => s.field === perm.field)) {
+      result.push(perm);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Convert a File to a base64 data URL string.
+ */
+export function file2Base64(file: File | { uid?: string } & Blob): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.readAsDataURL(file as Blob);
+    reader.addEventListener('load', () => {
+      resolve(reader.result as string);
+    });
+    reader.addEventListener('error', () => {
+      reject(reader.error);
+    });
+  });
+}
+
+/** Parse full CSV text respecting quoted multi-line fields */
+export function parseCSV(text: string): string[][] {
+  const rows: string[][] = [];
+  let currentRow: string[] = [];
+  let currentVal = '';
+  let inQuotes = false;
+
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inQuotes) {
+      if (ch === '"') {
+        if (i + 1 < text.length && text[i + 1] === '"') {
+          currentVal += '"';
+          i++; // skip escaped quote
+        } else {
+          inQuotes = false;
+        }
+      } else {
+        currentVal += ch;
+      }
+    } else {
+      if (ch === '"') {
+        inQuotes = true;
+      } else if (ch === ',') {
+        currentRow.push(currentVal.trim());
+        currentVal = '';
+      } else if (ch === '\n' || ch === '\r') {
+        currentRow.push(currentVal.trim());
+        if (currentRow.some(v => v !== '')) {
+          rows.push(currentRow);
+        }
+        currentRow = [];
+        currentVal = '';
+        if (ch === '\r' && i + 1 < text.length && text[i + 1] === '\n') {
+          i++; // consume \n of \r\n
+        }
+      } else {
+        currentVal += ch;
+      }
+    }
+  }
+  
+  if (currentVal || currentRow.length > 0) {
+    currentRow.push(currentVal.trim());
+    if (currentRow.some(v => v !== '')) {
+      rows.push(currentRow);
+    }
+  }
+  return rows;
+}

package/src/helpers.test.ts

@@ -0,0 +1,177 @@
+// Unit tests for helpers-pure.ts — pure functions, no Svelte runtime
+import { describe, test, expect } from 'bun:test';
+import {
+  getDefaultFilter, getDefaultSortOrder,
+  unionFilters, unionSorters,
+  parseCSV,
+} from './helpers-pure';
+import type { Filter, Sort } from './types';
+
+// ─── getDefaultFilter ─────────────────────────────────────────
+
+describe('getDefaultFilter', () => {
+  const filters: Filter[] = [
+    { field: 'status', operator: 'eq', value: 'published' },
+    { field: 'price', operator: 'gte', value: 100 },
+    { field: 'title', operator: 'contains', value: 'hello' },
+  ];
+
+  test('returns value for matching field+operator', () => {
+    expect(getDefaultFilter('status', filters)).toBe('published');
+    expect(getDefaultFilter('price', filters, 'gte')).toBe(100);
+  });
+
+  test('returns undefined for non-matching field', () => {
+    expect(getDefaultFilter('nonexistent', filters)).toBeUndefined();
+  });
+
+  test('returns undefined for wrong operator', () => {
+    expect(getDefaultFilter('status', filters, 'contains')).toBeUndefined();
+  });
+
+  test('returns undefined for empty/undefined filters', () => {
+    expect(getDefaultFilter('status', [])).toBeUndefined();
+    expect(getDefaultFilter('status', undefined)).toBeUndefined();
+  });
+});
+
+// ─── getDefaultSortOrder ──────────────────────────────────────
+
+describe('getDefaultSortOrder', () => {
+  const sorters: Sort[] = [
+    { field: 'name', order: 'asc' },
+    { field: 'createdAt', order: 'desc' },
+  ];
+
+  test('returns order for matching field', () => {
+    expect(getDefaultSortOrder('name', sorters)).toBe('asc');
+    expect(getDefaultSortOrder('createdAt', sorters)).toBe('desc');
+  });
+
+  test('returns undefined for non-matching field', () => {
+    expect(getDefaultSortOrder('unknown', sorters)).toBeUndefined();
+  });
+
+  test('returns undefined for empty/undefined sorters', () => {
+    expect(getDefaultSortOrder('name', undefined)).toBeUndefined();
+    expect(getDefaultSortOrder('name', [])).toBeUndefined();
+  });
+});
+
+// ─── unionFilters ─────────────────────────────────────────────
+
+describe('unionFilters', () => {
+  test('merges new filters over previous', () => {
+    const prev: Filter[] = [
+      { field: 'status', operator: 'eq', value: 'draft' },
+    ];
+    const next: Filter[] = [
+      { field: 'status', operator: 'eq', value: 'published' },
+    ];
+    const result = unionFilters([], next, prev);
+    expect(result).toHaveLength(1);
+    expect(result[0].value).toBe('published');
+  });
+
+  test('permanent filters override everything', () => {
+    const permanent: Filter[] = [
+      { field: 'org', operator: 'eq', value: 'acme' },
+    ];
+    const next: Filter[] = [
+      { field: 'org', operator: 'eq', value: 'other' },
+    ];
+    const result = unionFilters(permanent, next, []);
+    expect(result).toHaveLength(1);
+    expect(result[0].value).toBe('acme');
+  });
+
+  test('removes filters with undefined value', () => {
+    const prev: Filter[] = [
+      { field: 'status', operator: 'eq', value: 'draft' },
+    ];
+    const next: Filter[] = [
+      { field: 'status', operator: 'eq', value: undefined },
+    ];
+    const result = unionFilters([], next, prev);
+    expect(result).toHaveLength(0);
+  });
+
+  test('adds new filters not in previous', () => {
+    const prev: Filter[] = [
+      { field: 'status', operator: 'eq', value: 'draft' },
+    ];
+    const next: Filter[] = [
+      { field: 'category', operator: 'eq', value: 'tech' },
+    ];
+    const result = unionFilters([], next, prev);
+    expect(result).toHaveLength(2);
+  });
+
+  test('handles empty arrays', () => {
+    expect(unionFilters([], [], [])).toEqual([]);
+  });
+});
+
+// ─── unionSorters ─────────────────────────────────────────────
+
+describe('unionSorters', () => {
+  test('new sorters take priority', () => {
+    const permanent: Sort[] = [{ field: 'id', order: 'asc' }];
+    const newSorters: Sort[] = [{ field: 'name', order: 'desc' }];
+    const result = unionSorters(permanent, newSorters);
+    expect(result).toHaveLength(2);
+    expect(result[0].field).toBe('name');
+  });
+
+  test('permanent sorters are not duplicated', () => {
+    const permanent: Sort[] = [{ field: 'name', order: 'asc' }];
+    const newSorters: Sort[] = [{ field: 'name', order: 'desc' }];
+    const result = unionSorters(permanent, newSorters);
+    expect(result).toHaveLength(1);
+    expect(result[0].order).toBe('desc');
+  });
+
+  test('empty arrays', () => {
+    expect(unionSorters([], [])).toEqual([]);
+  });
+});
+
+// ─── parseCSV ─────────────────────────────────────────────────
+
+describe('parseCSV', () => {
+  test('parses simple CSV', () => {
+    const rows = parseCSV('name,age\nAlice,30\nBob,25');
+    expect(rows).toHaveLength(3);
+    expect(rows[0]).toEqual(['name', 'age']);
+    expect(rows[1]).toEqual(['Alice', '30']);
+    expect(rows[2]).toEqual(['Bob', '25']);
+  });
+
+  test('handles quoted fields', () => {
+    const rows = parseCSV('name,bio\nAlice,"Hello, World"');
+    expect(rows).toHaveLength(2);
+    expect(rows[1][1]).toBe('Hello, World');
+  });
+
+  test('handles escaped quotes', () => {
+    const rows = parseCSV('val\n"He said ""hello"""');
+    expect(rows).toHaveLength(2);
+    expect(rows[1][0]).toBe('He said "hello"');
+  });
+
+  test('handles CRLF line endings', () => {
+    const rows = parseCSV('a,b\r\n1,2\r\n3,4');
+    expect(rows).toHaveLength(3);
+  });
+
+  test('skips empty rows', () => {
+    const rows = parseCSV('a\n\nb\n');
+    expect(rows).toHaveLength(2);
+    expect(rows[0]).toEqual(['a']);
+    expect(rows[1]).toEqual(['b']);
+  });
+
+  test('handles empty input', () => {
+    expect(parseCSV('')).toEqual([]);
+  });
+});