@svadmin/core 0.0.3 → 0.3.0

package/src/context.ts

@@ -2,31 +2,77 @@
 
 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) ────────────────────────
+// ─── 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 {
@@ -35,15 +81,31 @@ 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;
 }
+
+// ─── 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

@@ -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; },
   };
 }